cursor-agent-scaffold 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# Cursor Agent Context & Rules Scaffold
+
+This is a **scaffold package** for setting up Cursor's AI agent context and rules system in your project.
+
+## What This Does
+
+This scaffold helps you set up a structured system for:
+- **Rules** - Prescriptive guidelines that enforce project conventions
+- **Context** - Learned patterns and decision frameworks discovered during development
+
+When you drop this into your `.cursor/` folder, the agent will help you:
+1. Analyze your codebase
+2. Create appropriate rules based on your tech stack
+3. Set up the context system for capturing patterns
+4. Maintain and evolve the system as you develop
+
+## Quick Start
+
+### Option 1: NPM Package (Recommended)
+
+Install and run the scaffold installer:
+
+```bash
+# Using npx (no installation needed)
+npx cursor-agent-scaffold
+
+# Or install globally
+npm install -g cursor-agent-scaffold
+cursor-scaffold
+```
+
+This will automatically copy all scaffold files to your `.cursor/` folder.
+
+### Option 2: Copy the Scaffold
+
+1. Copy the entire `.cursor-scaffold/` folder contents into your project's `.cursor/` folder:
+   ```bash
+   # Copy everything from .cursor-scaffold/ to .cursor/
+   cp -r .cursor-scaffold/* .cursor/
+   ```
+
+2. The agent will automatically detect the scaffold and guide you through setup
+
+### Option 3: Manual Setup
+
+1. Copy `rules/scaffold-agent-context.mdc` to `.cursor/rules/`
+2. Copy `README.md` to `.cursor/`
+3. Ask the agent: "Help me set up the context and rules system for this project"
+
+## What Gets Created
+
+After setup, you'll have:
+
+```
+.cursor/
+├── README.md                    # Documentation
+├── rules/                       # Prescriptive rules
+│   ├── scaffold-agent-context.mdc  # Setup guide (this file)
+│   ├── naming-and-structure.mdc    # Created by agent
+│   ├── lint-and-style.mdc          # Created by agent
+│   ├── framework-patterns.mdc       # Created by agent
+│   └── context-patterns.mdc         # Created by agent
+└── context/                     # Learned patterns (created as needed)
+    └── [pattern files].md
+```
+
+## How It Works
+
+1. **Initial Setup**: The agent analyzes your codebase and creates initial rules
+2. **Development**: As you work, the agent captures patterns in context files
+3. **Evolution**: Rules and context evolve as your project grows
+
+## Customization
+
+The scaffold is designed to be:
+- **Framework-agnostic** - Works with React, Vue, Angular, etc.
+- **Language-agnostic** - Works with TypeScript, JavaScript, Python, etc.
+- **Project-agnostic** - Adapts to your specific conventions
+
+The agent will customize rules based on:
+- Your tech stack (detected from config files)
+- Your existing code patterns
+- Your project structure
+
+## Next Steps
+
+1. **Copy this scaffold** into your `.cursor/` folder
+2. **Ask the agent** to analyze your codebase and create initial rules:
+   - "Analyze my codebase and create initial rules based on my tech stack"
+   - "Help me set up the context and rules system for this project"
+3. **Start developing** - context files will be created as patterns emerge
+
+## Example Agent Prompts
+
+After setup, try these prompts:
+
+- "Analyze my codebase and create initial rules"
+- "What rules should I have for this project?"
+- "Help me document the form validation patterns we've been using"
+- "Create a context file for our component composition patterns"
+- "Update the rules to reflect our new TypeScript strict mode requirement"
+
+## Support
+
+The scaffold includes:
+- `rules/scaffold-agent-context.mdc` - Detailed setup guide for the agent
+- `README.md` - Documentation for developers
+- Templates and examples for rules and context files
+
+## Installation Methods
+
+### NPM Package
+```bash
+npx cursor-agent-scaffold
+```
+
+### Git Repository
+```bash
+git clone <repo-url>
+cp -r cursor-agent-scaffold/* .cursor/
+```
+
+### Zip File
+Download and extract into `.cursor/` folder
+
+See `SHARING.md` for more distribution options.
+
+---
+
+**Note:** This scaffold is designed to work with Cursor's AI agent. The agent will read `scaffold-agent-context.mdc` and guide you through the setup process automatically.

package/SETUP.md

@@ -0,0 +1,87 @@
+# Quick Setup Guide
+
+## For Users Receiving This Scaffold
+
+### Step 1: Copy to Your Project
+
+Copy the contents of `.cursor-scaffold/` into your project's `.cursor/` folder:
+
+**On macOS/Linux:**
+```bash
+cp -r .cursor-scaffold/* .cursor/
+```
+
+**On Windows (PowerShell):**
+```powershell
+Copy-Item -Path .cursor-scaffold\* -Destination .cursor\ -Recurse
+```
+
+**Or manually:**
+1. Create a `.cursor/` folder in your project root (if it doesn't exist)
+2. Copy `rules/scaffold-agent-context.mdc` to `.cursor/rules/`
+3. Copy `README.md` to `.cursor/`
+
+### Step 2: Ask the Agent to Set Up
+
+Open Cursor and ask the agent:
+
+> "Help me set up the context and rules system for this project. Analyze my codebase and create initial rules based on my tech stack."
+
+The agent will:
+1. Analyze your codebase
+2. Detect your tech stack
+3. Create appropriate rule files
+4. Set up the context system
+
+### Step 3: Verify Setup
+
+After the agent completes setup, you should have:
+
+- `.cursor/rules/` with several `.mdc` rule files
+- `.cursor/context/` folder (empty initially, will be populated as patterns emerge)
+- `.cursor/README.md` with documentation
+
+### Step 4: Start Using
+
+The system is now active! The agent will:
+- Follow the rules when generating code
+- Create context files as patterns emerge
+- Reference both rules and context when working on tasks
+
+## What Happens Next?
+
+As you develop:
+
+1. **Rules** enforce your conventions automatically
+2. **Context files** are created when patterns emerge
+3. The agent references both when making decisions
+
+## Troubleshooting
+
+**The agent isn't detecting the scaffold:**
+- Make sure `scaffold-agent-context.mdc` is in `.cursor/rules/`
+- Try asking: "Read the scaffold-agent-context rule and help me set up the system"
+
+**Rules aren't being created:**
+- Explicitly ask: "Analyze my codebase and create initial rules"
+- Provide context about your tech stack if needed
+
+**Need to customize:**
+- Edit rule files after they're created
+- The agent will follow your customizations
+
+## Example Conversation
+
+```
+You: Help me set up the context and rules system for this project.
+
+Agent: [Analyzes codebase, detects React + TypeScript + Tailwind]
+       [Creates rules for naming, linting, framework patterns, etc.]
+       [Sets up context system]
+
+You: Great! Now help me document our form validation patterns.
+
+Agent: [Creates context/form-validation-patterns.md based on your code]
+```
+
+That's it! The system is self-maintaining once set up.

package/SHARING.md

@@ -0,0 +1,122 @@
+# Sharing This Scaffold
+
+This document explains how to share the Cursor Agent Context & Rules Scaffold with others.
+
+## What to Share
+
+Share the entire `.cursor-scaffold/` folder. It contains:
+
+- `README.md` - Main documentation
+- `SETUP.md` - Quick setup guide
+- `rules/scaffold-agent-context.mdc` - The agent instruction file
+
+## Distribution Methods
+
+### Option 1: Git Repository
+
+Create a repository with just the scaffold:
+
+```bash
+# Create a new repo
+git init cursor-agent-scaffold
+cd cursor-agent-scaffold
+
+# Copy the scaffold folder
+cp -r /path/to/project/.cursor-scaffold/* .
+
+# Commit and push
+git add .
+git commit -m "Initial scaffold release"
+git remote add origin <your-repo-url>
+git push -u origin main
+```
+
+Others can then:
+
+```bash
+git clone <your-repo-url>
+cp -r cursor-agent-scaffold/* their-project/.cursor/
+```
+
+### Option 2: Zip File
+
+```bash
+# Create a zip
+cd .cursor-scaffold
+zip -r ../cursor-agent-scaffold.zip .
+```
+
+Share the zip file. Recipients extract it into their `.cursor/` folder.
+
+### Option 3: NPM Package (Advanced)
+
+If you want to distribute via npm:
+
+1. Create a `package.json`:
+
+```json
+{
+  "name": "cursor-agent-scaffold",
+  "version": "1.0.0",
+  "description": "Scaffold for Cursor AI agent context and rules system",
+  "files": ["README.md", "SETUP.md", "rules/"]
+}
+```
+
+2. Publish:
+
+```bash
+npm publish
+```
+
+3. Users install:
+
+```bash
+npm install cursor-agent-scaffold
+cp -r node_modules/cursor-agent-scaffold/* .cursor/
+```
+
+### Option 4: Direct Copy
+
+Simply share the `.cursor-scaffold/` folder directly via:
+
+- File sharing service (Dropbox, Google Drive, etc.)
+- Email (if small enough)
+- Team drive/shared folder
+
+## What Recipients Need to Do
+
+1. Copy contents to `.cursor/` folder
+2. Ask the agent: "Help me set up the context and rules system"
+3. The agent handles the rest!
+
+## Versioning
+
+If you update the scaffold:
+
+1. Update version in documentation
+2. Note changes in a CHANGELOG
+3. Share updated version
+
+## Customization Before Sharing
+
+You can customize the scaffold before sharing:
+
+- Add project-specific examples
+- Include common rule templates
+- Add context file examples
+- Customize the README with your branding
+
+Just remember: The scaffold should remain **framework-agnostic** and **project-agnostic** to be useful to others.
+
+## License
+
+Consider adding a LICENSE file if you plan to share publicly. MIT or CC0 are good choices for this type of tooling.
+
+## Support
+
+When sharing, include:
+
+- Link to this README
+- Instructions to read SETUP.md
+- Your contact info if you want to provide support

package/bin/install.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+/**
+ * Installation script for cursor-agent-scaffold
+ * Copies scaffold files to .cursor/ folder in the current directory
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SCAFFOLD_DIR = __dirname.replace(/[\\/]bin$/, '');
+const TARGET_DIR = path.join(process.cwd(), '.cursor');
+
+// Files to copy (relative to scaffold root)
+const FILES_TO_COPY = [
+  'README.md',
+  'SETUP.md',
+  'SHARING.md',
+  'rules/scaffold-agent-context.mdc',
+];
+
+function copyFile(src, dest) {
+  const destDir = path.dirname(dest);
+  if (!fs.existsSync(destDir)) {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+  fs.copyFileSync(src, dest);
+  console.log(`✓ Copied ${path.relative(process.cwd(), dest)}`);
+}
+
+function main() {
+  console.log('🚀 Installing Cursor Agent Context & Rules Scaffold...\n');
+
+  // Create .cursor directory if it doesn't exist
+  if (!fs.existsSync(TARGET_DIR)) {
+    fs.mkdirSync(TARGET_DIR, { recursive: true });
+    console.log(`✓ Created ${path.relative(process.cwd(), TARGET_DIR)}/ directory\n`);
+  }
+
+  // Create rules directory
+  const rulesDir = path.join(TARGET_DIR, 'rules');
+  if (!fs.existsSync(rulesDir)) {
+    fs.mkdirSync(rulesDir, { recursive: true });
+  }
+
+  // Copy files
+  let copied = 0;
+  for (const file of FILES_TO_COPY) {
+    const src = path.join(SCAFFOLD_DIR, file);
+    const dest = path.join(TARGET_DIR, file);
+
+    if (fs.existsSync(src)) {
+      copyFile(src, dest);
+      copied++;
+    } else {
+      console.warn(`⚠ Warning: ${file} not found in scaffold`);
+    }
+  }
+
+  console.log(`\n✅ Successfully installed ${copied} file(s) to .cursor/`);
+  console.log('\n📖 Next steps:');
+  console.log('   1. Open Cursor');
+  console.log('   2. Ask the agent: "Help me set up the context and rules system for this project"');
+  console.log('   3. The agent will analyze your codebase and create appropriate rules\n');
+}
+
+// Run if called directly
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error('❌ Error installing scaffold:', error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { main };

package/bin/verify.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+/**
+ * Verification script run before publishing
+ * Ensures all required files are present
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const REQUIRED_FILES = [
+  'README.md',
+  'SETUP.md',
+  'SHARING.md',
+  'rules/scaffold-agent-context.mdc',
+  'package.json',
+  'bin/install.js',
+];
+
+function verify() {
+  const scaffoldDir = __dirname.replace(/[\\/]bin$/, '');
+  const missing = [];
+
+  for (const file of REQUIRED_FILES) {
+    const filePath = path.join(scaffoldDir, file);
+    if (!fs.existsSync(filePath)) {
+      missing.push(file);
+    }
+  }
+
+  if (missing.length > 0) {
+    console.error('❌ Missing required files:');
+    missing.forEach(file => console.error(`   - ${file}`));
+    process.exit(1);
+  }
+
+  console.log('✅ All required files present');
+}
+
+verify();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "cursor-agent-scaffold",
+  "version": "1.0.0",
+  "description": "Scaffold package for setting up Cursor AI agent context and rules system",
+  "keywords": [
+    "cursor",
+    "ai",
+    "agent",
+    "scaffold",
+    "rules",
+    "context",
+    "development-tools"
+  ],
+  "author": "C.G.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "files": [
+    "README.md",
+    "SETUP.md",
+    "SHARING.md",
+    "PUBLISHING.md",
+    "LICENSE",
+    "rules/",
+    "bin/"
+  ],
+  "bin": {
+    "cursor-scaffold": "./bin/install.js"
+  },
+  "scripts": {
+    "prepublishOnly": "node bin/verify.js"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/rules/scaffold-agent-context.mdc

@@ -0,0 +1,342 @@
+---
+description: Scaffold Agent Context System — Guide for setting up and maintaining context/rules structure
+globs:
+  - ".cursor/**/*"
+alwaysApply: true
+---
+
+# Scaffold Agent Context System
+
+This document guides the agent on how to set up, maintain, and evolve the `.cursor/` folder structure for context and rules.
+
+## System Overview
+
+The `.cursor/` folder contains two complementary systems:
+
+### Rules (`.cursor/rules/*.mdc`)
+**Purpose:** Prescriptive guidelines, requirements, and policies that must be followed.
+
+**Characteristics:**
+- Written as `.mdc` files with frontmatter (description, globs, alwaysApply)
+- Define **what** must be done and **how** code should be structured
+- Examples: naming conventions, linting policies, folder structure, design system rules
+- Should be created early in project setup
+- Apply broadly across the codebase
+
+**When to create a rule:**
+- Project-wide conventions (naming, file structure, linting)
+- Design system requirements (tokens, variants, accessibility)
+- Framework-specific patterns (routing, SSR, form handling)
+- Quality gates and workflows (CI/CD, testing requirements)
+
+### Context (`.cursor/context/*.md`)
+**Purpose:** Learned patterns, decision frameworks, and best practices discovered during development.
+
+**Characteristics:**
+- Written as markdown files (`.md`)
+- Document **why** decisions were made and **when** to apply patterns
+- Capture patterns discovered through refactoring and problem-solving
+- Created organically as patterns emerge
+- Reference specific components, utilities, or architectural decisions
+
+**When to create a context file:**
+- After refactoring reveals a reusable pattern
+- When a decision framework is needed for similar future tasks
+- When documenting component composition strategies
+- When capturing domain-specific patterns (e.g., form handling, navigation)
+
+## Setup Instructions for New Projects
+
+When a user drops this scaffold into an empty `.cursor/` folder, follow these steps:
+
+### Step 1: Analyze the Codebase
+
+1. **Identify the tech stack:**
+   - Framework (React, Vue, Angular, etc.)
+   - Styling approach (Tailwind, CSS modules, styled-components, etc.)
+   - State management (Redux, Zustand, Context API, etc.)
+   - Routing (React Router, Next.js, Inertia, etc.)
+   - Form handling (React Hook Form, Formik, Inertia Forms, etc.)
+
+2. **Examine existing patterns:**
+   - File structure and organization
+   - Component naming conventions
+   - Import/export patterns
+   - Styling conventions
+   - Testing approach
+
+3. **Review configuration files:**
+   - `package.json` (scripts, dependencies)
+   - Linting config (ESLint, Prettier)
+   - TypeScript config
+   - Build tools config
+
+### Step 2: Create Initial Rules
+
+Create rule files (`.mdc`) for each major area:
+
+**Required rules to consider:**
+
+1. **`naming-and-structure.mdc`**
+   - File naming conventions (kebab-case, PascalCase, etc.)
+   - Component naming
+   - Folder structure
+   - Import/export patterns
+
+2. **`lint-and-style.mdc`**
+   - Linting requirements
+   - Formatting rules
+   - When to suppress vs fix
+   - Quality gates
+
+3. **`design-system.mdc`** (if applicable)
+   - Design tokens
+   - Component variants
+   - Accessibility requirements
+   - Theme/color system
+
+4. **`framework-patterns.mdc`**
+   - Framework-specific patterns
+   - Routing conventions
+   - State management patterns
+   - SSR/hydration considerations
+
+5. **`workflows-and-ci.mdc`**
+   - Development workflows
+   - Git conventions
+   - CI/CD requirements
+   - Testing requirements
+
+**Rule file template:**
+
+```markdown
+---
+description: [Brief description of what this rule covers]
+globs:
+  - "[path patterns to apply to, e.g., 'src/**/*', 'components/**/*']"
+alwaysApply: true
+---
+
+# [Rule Title]
+
+## [Section 1]
+
+- [Guideline 1]
+- [Guideline 2]
+
+## [Section 2]
+
+- [Guideline 3]
+- [Guideline 4]
+
+## Do / Don't
+
+- ✅ [Good practice]
+- ❌ [Bad practice]
+```
+
+### Step 3: Create Context Scaffold
+
+Create a `context-patterns.mdc` rule file that explains the context system:
+
+```markdown
+---
+description: Reference context patterns — when to consult learned knowledge
+globs:
+  - "[your source paths]"
+alwaysApply: true
+---
+
+## Context Knowledge Base
+
+The `.cursor/context/` directory contains **learned patterns and knowledge** from working on this project. These files capture specific decisions, refactoring strategies, and best practices discovered during development.
+
+## How to Use Context Files
+
+1. **Before starting a task**, check if any context files are relevant
+2. **When encountering patterns** mentioned in context files, follow the documented approach
+3. **When making decisions**, reference the decision frameworks in context files
+4. **After implementing**, verify your approach aligns with documented patterns
+
+## Integration with Rules
+
+Context files complement the rules in `.cursor/rules/`:
+- **Rules** = Prescriptive guidelines and requirements
+- **Context** = Learned patterns, decision frameworks, and best practices
+
+Both should be considered when working on code.
+```
+
+### Step 4: Document the System
+
+Create a `README.md` in `.cursor/` explaining:
+- What rules vs context are
+- How to use them
+- How to add new ones
+- Examples from the codebase
+
+## Maintaining the System
+
+### When to Create a New Rule
+
+Create a new rule file when:
+- A new project-wide convention is established
+- A new framework/technology is adopted
+- Quality gates or workflows change
+- A pattern needs to be enforced across the codebase
+
+**Example triggers:**
+- "We're adopting TypeScript strict mode"
+- "All forms must use React Hook Form"
+- "Components must be tested with React Testing Library"
+
+### When to Create a New Context File
+
+Create a new context file when:
+- A refactoring reveals a reusable pattern
+- A decision framework is needed for similar tasks
+- Component composition strategies emerge
+- Domain-specific patterns are discovered
+
+**Example triggers:**
+- "We refactored the Button component and learned when to use variants vs separate components"
+- "We built three forms and discovered patterns for validation"
+- "We created a navigation system and learned external link handling patterns"
+
+### Context File Template
+
+```markdown
+# [Pattern Name]
+
+This document captures patterns, decisions, and best practices learned from [specific task/refactoring].
+
+## Overview
+
+This document focuses on:
+- [Key area 1]
+- [Key area 2]
+- [Key area 3]
+
+## Decision Framework
+
+When [situation], consider:
+
+1. **Factor 1**
+   - [Consideration]
+   - [Consideration]
+
+2. **Factor 2**
+   - [Consideration]
+   - [Consideration]
+
+## Patterns
+
+### Pattern Name
+
+**When to use:**
+- [Situation 1]
+- [Situation 2]
+
+**Implementation:**
+```typescript
+// Example code
+```
+
+**Key guidance:**
+- [Guideline 1]
+- [Guideline 2]
+
+## Examples
+
+[Real examples from codebase]
+
+## Anti-patterns
+
+❌ **Don't:**
+```typescript
+// Bad example
+```
+
+✅ **Do:**
+```typescript
+// Good example
+```
+```
+
+### Updating Context Files
+
+When working on tasks:
+1. **Before starting:** Check relevant context files
+2. **During work:** Note patterns that emerge
+3. **After completion:** Update or create context files if:
+   - A new pattern was discovered
+   - A decision framework was developed
+   - An existing pattern needs clarification
+
+### Updating Rules
+
+Update rules when:
+- Conventions change
+- New requirements are added
+- Patterns become project-wide standards
+- Quality gates evolve
+
+## Best Practices
+
+### Rule Writing
+- Be specific and actionable
+- Include examples (good and bad)
+- Reference related rules/context files
+- Use clear section headers
+- Include "Do / Don't" sections
+
+### Context Writing
+- Start with the problem/situation
+- Document the decision framework
+- Include code examples
+- Explain why, not just what
+- Reference specific files/components when helpful
+- Update as patterns evolve
+
+### Organization
+- Keep rules focused (one major area per file)
+- Name context files descriptively (e.g., `form-validation-patterns.md`)
+- Cross-reference related files
+- Keep files maintainable (split if too long)
+
+## Example Workflow
+
+**Scenario:** Building a new form component
+
+1. **Check rules:**
+   - `framework-patterns.mdc` for form handling conventions
+   - `design-system.mdc` for form field styling
+   - `lint-and-style.mdc` for code quality
+
+2. **Check context:**
+   - `form-validation-patterns.md` (if exists)
+   - `component-composition-patterns.md` (if exists)
+
+3. **Build the component** following rules and context
+
+4. **After completion:**
+   - If new patterns emerged → create/update context file
+   - If conventions need enforcement → update/create rule
+
+## Integration with Agent Behavior
+
+The agent should:
+- **Always check relevant context files** before starting tasks
+- **Reference context files** when making decisions
+- **Update context files** when patterns are discovered
+- **Follow rules** as authoritative requirements
+- **Suggest rule updates** when patterns become project-wide
+
+## Quick Reference
+
+| Type | Format | When to Create | Purpose |
+|------|--------|----------------|---------|
+| **Rule** | `.mdc` with frontmatter | Early setup, project-wide conventions | Enforce requirements |
+| **Context** | `.md` markdown | As patterns emerge | Document learned patterns |
+
+**Remember:** Rules tell you **what** to do. Context tells you **why** and **when**.