diff --git a/WARP.md b/WARP.md
new file mode 100644
index 0000000..4195703
--- /dev/null
+++ b/WARP.md
@@ -0,0 +1,492 @@
+# WARP.md - STRUCT Project Guide
+
+> This file serves as a comprehensive guide for developers working with the STRUCT project. It contains project-specific conventions, development workflows, and institutional knowledge.
+
+## 📋 Table of Contents
+
+- [Project Overview](#project-overview)
+- [Development Environment](#development-environment)
+- [Code Structure](#code-structure)
+- [Development Workflow](#development-workflow)
+- [Testing Guidelines](#testing-guidelines)
+- [Code Style & Standards](#code-style--standards)
+- [Release Process](#release-process)
+- [Common Tasks](#common-tasks)
+- [Troubleshooting](#troubleshooting)
+- [Architecture Decisions](#architecture-decisions)
+- [Performance Considerations](#performance-considerations)
+- [Security Guidelines](#security-guidelines)
+- [Documentation Standards](#documentation-standards)
+- [Dependencies & Tools](#dependencies--tools)
+- [Monitoring & Observability](#monitoring--observability)
+- [Issue & Work Management](#issue--work-management)
+
+## 🎯 Project Overview
+
+### Mission
+STRUCT simplifies project organization by creating consistent file and folder structures tailored to specific needs. It enhances productivity and maintains uniformity across projects through YAML-based configuration files.
+
+### Key Features
+- **YAML-Based Configuration**: Simple, readable project structure definitions
+- **Template Variables**: Dynamic content with Jinja2 templating and interactive prompts
+- **Remote Content Fetching**: Support for GitHub, HTTP/HTTPS, S3, and Google Cloud Storage
+- **Smart File Handling**: Multiple strategies for managing existing files
+- **Automation Hooks**: Pre and post-generation shell commands
+- **MCP Integration**: Model Context Protocol support for AI-assisted workflows
+
+### Technology Stack
+- **Language**: Python 3.12+
+- **CLI Framework**: argparse with custom command pattern
+- **Templating**: Jinja2 with custom delimiters
+- **Testing**: pytest with coverage reporting
+- **Documentation**: MkDocs with Material theme
+- **CI/CD**: GitHub Actions
+- **Package Management**: pip with requirements.txt
+
+## 🛠 Development Environment
+
+### Prerequisites
+```bash
+# Python 3.12 or higher
+python --version
+
+# Virtual environment (recommended)
+python -m venv .venv
+source .venv/bin/activate  # Linux/macOS
+# or
+.venv\Scripts\activate     # Windows
+
+# Install dependencies
+pip install -r requirements.txt
+pip install -r requirements.dev.txt
+```
+
+### Environment Variables
+```bash
+# Optional: OpenAI API key for AI features
+export OPENAI_API_KEY="your-api-key-here"
+
+# Optional: GitHub token for private repo access
+export GITHUB_TOKEN="your-github-token"
+
+# Optional: Logging level
+export STRUCT_LOG_LEVEL="DEBUG"
+```
+
+### IDE Configuration
+- **VS Code**: Recommended extensions in `.vscode/extensions.json`
+- **PyCharm**: Python interpreter should point to `.venv/bin/python`
+- **Pre-commit hooks**: Run `pre-commit install` after setup
+
+## 🏗 Code Structure
+
+### Directory Layout
+```
+struct_module/
+├── commands/           # CLI command implementations
+│   ├── generate.py    # Main generation command
+│   ├── validate.py    # YAML validation
+│   ├── list.py        # List available structures
+│   └── ...
+├── contribs/          # Built-in structure templates
+├── filters.py         # Jinja2 custom filters
+├── template_renderer.py  # Core templating logic
+├── file_item.py       # File handling and processing
+├── input_store.py     # User input persistence
+├── utils.py           # Utility functions
+└── main.py           # Entry point
+
+tests/                 # Test suite
+docs/                  # Documentation source
+examples/              # Example configurations
+```
+
+### Key Modules
+
+#### `template_renderer.py`
+- Handles Jinja2 templating with custom delimiters
+- Interactive variable prompting with descriptions
+- Type coercion and validation
+- Icon-based user interface
+
+#### `file_item.py`
+- Represents files to be created/modified
+- Handles different content sources (inline, remote, etc.)
+- Implements file creation strategies (overwrite, skip, backup, etc.)
+
+#### `commands/`
+- Each command is a separate class inheriting from `Command`
+- Self-contained argument parsing and execution logic
+- Consistent error handling and logging
+
+## 🔄 Development Workflow
+
+### Branch Strategy
+- `main`: Production-ready code
+- `feature/*`: New features (e.g., `feature/display-variable-descriptions-116`)
+- `bugfix/*`: Bug fixes
+- `hotfix/*`: Critical production fixes
+- `docs/*`: Documentation updates
+
+### Commit Message Convention
+```
+<type>(<scope>): <description>
+
+<body>
+
+<footer>
+```
+
+Types: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`
+
+Examples:
+```
+feat(template): add variable description display in interactive mode
+fix(file-handling): resolve path resolution on Windows
+docs(api): update template variables documentation
+```
+
+### Pull Request Process
+1. Create feature branch from `main`
+2. Implement changes with tests
+3. Update documentation if needed
+4. Run full test suite: `pytest tests/`
+5. Check code style: `pre-commit run --all-files`
+6. Create PR with descriptive title and body
+7. Link related issues: "Closes #123"
+8. Request review from maintainers
+
+## 🧪 Testing Guidelines
+
+### Test Structure
+```bash
+# Run all tests
+pytest tests/
+
+# Run with coverage
+pytest tests/ --cov=struct_module --cov-report=html
+
+# Run specific test file
+pytest tests/test_template_renderer.py -v
+
+# Run specific test
+pytest tests/test_template_renderer.py::test_prompt_with_description_display -v
+```
+
+### Test Categories
+- **Unit Tests**: Individual component testing
+- **Integration Tests**: Cross-component functionality
+- **Command Tests**: CLI command end-to-end testing
+- **Template Tests**: YAML configuration validation
+
+### Test Data
+- Test fixtures in `tests/fixtures/`
+- Mock objects for external dependencies
+- Temporary files in `/tmp/` for file system tests
+
+### Coverage Goals
+- Minimum 85% line coverage
+- All new features must include tests
+- Critical paths require 100% coverage
+
+## 📝 Code Style & Standards
+
+### Python Style
+- **PEP 8** compliance with line length of 100 characters
+- **Type hints** for all public functions
+- **Docstrings** for all modules, classes, and public functions
+- **F-strings** for string formatting
+
+### Code Quality Tools
+```bash
+# Linting
+flake8 struct_module/
+
+# Type checking
+mypy struct_module/
+
+# Pre-commit hooks (automated)
+pre-commit run --all-files
+```
+
+### Variable Naming
+- `snake_case` for variables and functions
+- `UPPER_CASE` for constants
+- Descriptive names over abbreviations
+- Prefix private methods with underscore
+
+### Error Handling
+- Use specific exception types
+- Provide helpful error messages
+- Log errors with appropriate levels
+- Clean up resources in finally blocks
+
+## 🚀 Release Process
+
+### Version Numbering
+- Semantic versioning: `MAJOR.MINOR.PATCH`
+- `MAJOR`: Breaking changes
+- `MINOR`: New features, backward compatible
+- `PATCH`: Bug fixes
+
+### Release Checklist
+1. Update `CHANGELOG.md`
+2. Bump version in `setup.py`
+3. Run full test suite
+4. Update documentation
+5. Create release PR
+6. Tag release: `git tag v1.2.3`
+7. GitHub Actions handles PyPI publication
+
+### Release Notes
+- Categorize changes: Added, Changed, Fixed, Removed
+- Include migration notes for breaking changes
+- Reference GitHub issues and PRs
+- Highlight security fixes
+
+## 🔧 Common Tasks
+
+### Adding a New Command
+1. Create new file in `struct_module/commands/`
+2. Inherit from `Command` base class
+3. Implement `__init__` with argument parsing
+4. Implement `execute` method
+5. Add command to `main.py`
+6. Add tests in `tests/test_commands.py`
+
+### Adding New Template Filters
+1. Implement filter function in `struct_module/filters.py`
+2. Add to `custom_filters` dict in `template_renderer.py`
+3. Document in `docs/template-variables.md`
+4. Add tests in `tests/test_filters.py`
+
+### Creating Built-in Structures
+1. Create YAML file in `struct_module/contribs/`
+2. Follow naming convention: `project-type.yaml`
+3. Include comprehensive variable definitions
+4. Add example in `docs/examples/`
+5. Update `struct list` output
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+#### Template Variables Not Resolving
+- Check custom delimiters: `{{@` `@}}`
+- Verify variable names match configuration
+- Check for typos in YAML structure
+
+#### File Creation Failures
+- Verify file permissions
+- Check disk space
+- Validate file paths (no invalid characters)
+- Review file strategy settings
+
+#### Import Errors
+- Ensure virtual environment is activated
+- Check Python version compatibility
+- Verify all dependencies installed: `pip install -r requirements.txt`
+
+### Debug Mode
+```bash
+# Enable debug logging
+export STRUCT_LOG_LEVEL=DEBUG
+struct generate config.yaml --log DEBUG
+
+# Dry run mode for testing
+struct generate config.yaml ./output --dry-run
+
+# Console output for inspection
+struct generate config.yaml --output console
+```
+
+### Log Analysis
+- Logs include timestamps and severity levels
+- File operations logged with full paths
+- Template rendering logged with variable values
+- Error stack traces include line numbers
+
+## 🏛 Architecture Decisions
+
+### Template Engine Choice (Jinja2)
+- **Decision**: Use Jinja2 with custom delimiters
+- **Rationale**: Mature, well-documented, powerful
+- **Trade-offs**: Custom delimiters prevent YAML conflicts
+- **Date**: 2024-07-11
+
+### Command Pattern Implementation
+- **Decision**: Each CLI command is a separate class
+- **Rationale**: Modular, testable, extensible
+- **Trade-offs**: Slightly more boilerplate
+- **Date**: 2024-07-15
+
+### File Strategy System
+- **Decision**: Pluggable file handling strategies
+- **Rationale**: Flexibility for different use cases
+- **Trade-offs**: Increased complexity
+- **Date**: 2024-08-01
+
+## ⚡ Performance Considerations
+
+### Template Rendering
+- Templates compiled once and cached
+- Variable resolution optimized for common cases
+- Large files streamed rather than loaded in memory
+
+### File Operations
+- Batch operations where possible
+- Minimal filesystem stat calls
+- Progress indicators for long operations
+
+### Memory Usage
+- File contents not held in memory unnecessarily
+- Generator patterns for large datasets
+- Proper cleanup of temporary resources
+
+## 🔐 Security Guidelines
+
+### Input Validation
+- All user inputs validated and sanitized
+- Path traversal protection in file operations
+- YAML parsing with safe loader only
+
+### External Content
+- HTTPS required for remote content
+- Validate SSL certificates
+- Timeout limits for network operations
+- Size limits for downloaded content
+
+### Secrets Handling
+- Never log sensitive information
+- Environment variables for API keys
+- Mask secrets in error messages
+- Clear sensitive data from memory
+
+## 📚 Documentation Standards
+
+### Code Documentation
+- Docstrings follow Google style
+- Type hints for all parameters and returns
+- Examples in docstrings for complex functions
+- Inline comments for non-obvious logic
+
+### User Documentation
+- Step-by-step tutorials with examples
+- Reference documentation for all features
+- Troubleshooting guides with common solutions
+- Migration guides for breaking changes
+
+### API Documentation
+- Auto-generated from docstrings
+- Include usage examples
+- Document exceptions and error conditions
+- Keep in sync with code changes
+
+## 📦 Dependencies & Tools
+
+### Core Dependencies
+- `Jinja2`: Template engine
+- `PyYAML`: YAML parsing
+- `requests`: HTTP client
+- `boto3`: AWS S3 integration
+- `google-cloud-storage`: GCS integration
+
+### Development Dependencies
+- `pytest`: Testing framework
+- `coverage`: Code coverage
+- `flake8`: Linting
+- `pre-commit`: Git hooks
+- `mkdocs`: Documentation
+
+### Optional Dependencies
+- `openai`: AI integration
+- `anthropic`: Claude integration
+- `fastapi`: MCP server support
+
+### Dependency Management
+- Pin major versions in `requirements.txt`
+- Regular security updates
+- Remove unused dependencies
+- Document version constraints
+
+## 📊 Monitoring & Observability
+
+### Metrics Collection
+- Command execution times
+- File operation success rates
+- Template rendering performance
+- Error rates by category
+
+### Logging Strategy
+- Structured logging with JSON format
+- Different log levels for different audiences
+- Correlation IDs for tracing requests
+- Log rotation and retention policies
+
+### Health Checks
+- Basic functionality verification
+- External service connectivity
+- Resource availability checks
+- Performance regression detection
+
+## 🐙 Issue & Work Management
+
+### GitHub MCP for Issues
+This project uses **GitHub** for issue tracking and work management. All issue-related queries and work management should use the GitHub MCP tools, **not Jira**.
+
+### Common GitHub MCP Operations
+
+#### List Issues
+```bash
+# Use the GitHub MCP to list all open issues
+list_issues owner:httpdss repo:struct state:open
+```
+
+#### Get Issue Details
+```bash
+# Get details for a specific issue number
+get_issue owner:httpdss repo:struct issue_number:100
+```
+
+#### Create an Issue
+```bash
+# Create a new issue
+create_issue owner:httpdss repo:struct title:"Issue Title" body:"Issue description"
+```
+
+#### Search Issues
+```bash
+# Search for issues by keyword or status
+search_issues query:"keyword" owner:httpdss repo:struct
+```
+
+### Issue Workflow
+1. **Browse Issues**: Use `list_issues` to see current open issues
+2. **Get Details**: Use `get_issue` to understand specific issue requirements
+3. **Comment**: Use `add_issue_comment` to provide updates
+4. **Link PRs**: Use "Closes #123" in pull requests to link them to issues
+
+---
+
+## 📝 Notes & TODOs
+
+### Future Enhancements
+- [ ] Plugin system for custom commands
+- [ ] GUI interface for non-technical users
+- [ ] Integration with more cloud providers
+- [ ] Advanced template debugging tools
+- [ ] Performance profiling dashboard
+
+### Known Limitations
+- Large file handling could be optimized
+- Windows path handling has edge cases
+- Some template features not well documented
+- MCP integration is still experimental
+
+---
+
+*This document is living documentation. Please update it as the project evolves.*
+
+**Last Updated**: 2025-09-22
+**Version**: 1.0
+**Maintainer**: Kenneth Belitzky (@httpdss)
diff --git a/docs/template-variables.md b/docs/template-variables.md
index 3ea9335..81e2620 100644
--- a/docs/template-variables.md
+++ b/docs/template-variables.md
@@ -66,7 +66,7 @@ STRUCT provides these built-in variables:
 
 ## Interactive Variables
 
-Define variables that prompt users for input:
+Define variables that prompt users for input. When running in interactive mode, STRUCT will display the variable's description to help users understand what value is expected:
 
 ```yaml
 variables:
@@ -84,6 +84,39 @@ variables:
       default: 8080
 ```
 
+When prompted interactively, variables with descriptions will display with contextual icons, **bold variable names**, and clean formatting:
+
+```
+🚀 project_name: The name of your project
+   Enter value [MyProject]:
+
+🌍 environment: Target deployment environment
+   Options: (1) dev, (2) staging, (3) prod
+   Enter value [dev]:
+```
+
+For variables without descriptions, a more compact format is used:
+
+```
+🔧 author_name []:
+⚡ enable_logging [true]:
+```
+
+**Note**: Variable names appear in **bold** in actual terminal output for better readability.
+
+**Contextual Icons**: STRUCT automatically selects appropriate icons based on variable names and types:
+- 🚀 Project/app names
+- 🌍 Environment/deployment variables
+- 🔌 Ports/network settings
+- 🗄️ Database configurations
+- ⚡ Boolean/toggle options
+- 🔐 Authentication/secrets
+- 🏷️ Versions/tags
+- 📁 Paths/directories
+- 🔧 General variables
+
+**Note**: The `description` field is displayed in interactive mode only. You can also use the legacy `help` field which works the same way.
+
 ### Variable Types
 
 - `string`: Text values
diff --git a/struct_module/template_renderer.py b/struct_module/template_renderer.py
index 30a3c97..9d634f4 100644
--- a/struct_module/template_renderer.py
+++ b/struct_module/template_renderer.py
@@ -99,6 +99,38 @@ def render_template(self, content, vars):
       template = self.env.from_string(content)
       return template.render(vars)
 
+    def _get_variable_icon(self, var_name, var_type):
+      """Get contextual icon for variable based on name and type"""
+      var_lower = var_name.lower()
+
+      # Project/name related
+      if any(keyword in var_lower for keyword in ['project', 'name', 'app', 'title']):
+        return '🚀'
+      # Environment related
+      elif any(keyword in var_lower for keyword in ['env', 'environment', 'stage', 'deploy']):
+        return '🌍'
+      # Database related (check before URL to prioritize database_url)
+      elif any(keyword in var_lower for keyword in ['db', 'database', 'sql']):
+        return '🗄️'
+      # Port/network related
+      elif any(keyword in var_lower for keyword in ['port', 'url', 'host', 'endpoint']):
+        return '🔌'
+      # Boolean/toggle related
+      elif var_type == 'boolean' or any(keyword in var_lower for keyword in ['enable', 'disable', 'toggle', 'flag']):
+        return '⚡'
+      # Authentication/security
+      elif any(keyword in var_lower for keyword in ['token', 'key', 'secret', 'password', 'auth']):
+        return '🔐'
+      # Version/tag related
+      elif any(keyword in var_lower for keyword in ['version', 'tag', 'release']):
+        return '🏷️'
+      # Path/directory related
+      elif any(keyword in var_lower for keyword in ['path', 'dir', 'folder']):
+        return '📁'
+      # Default
+      else:
+        return '🔧'
+
     def prompt_for_missing_vars(self, content, vars):
       parsed_content = self.env.parse(content)
       undeclared_variables = meta.find_undeclared_variables(parsed_content)
@@ -127,10 +159,29 @@ def prompt_for_missing_vars(self, content, vars):
           else:
             # Interactive prompt with enum support (choose by value or index)
             enum = conf.get('enum')
+            var_type = conf.get('type', 'string')
+
+            # Get description if available (support both 'description' and 'help' fields)
+            description = conf.get('description') or conf.get('help')
+
+            # Get contextual icon
+            icon = self._get_variable_icon(var, var_type)
+
+            # ANSI color codes for formatting
+            BOLD = '\033[1m'
+            RESET = '\033[0m'
+
             if enum:
-              # Build options list string like "(1) dev, (2) prod)"
+              # Build options list string like "(1) dev, (2) staging, (3) prod"
               options = ", ".join([f"({i+1}) {val}" for i, val in enumerate(enum)])
-              raw = input(f"❓ Enter value for {var} [{default}] {options}: ")
+
+              if description:
+                print(f"{icon} {BOLD}{var}{RESET}: {description}")
+                print(f"   Options: {options}")
+                raw = input(f"   Enter value [{default}]: ") or default
+              else:
+                raw = input(f"{icon} {BOLD}{var}{RESET} [{default}] {options}: ") or default
+
               raw = raw.strip()
               if raw == "":
                 user_input = default
@@ -142,7 +193,11 @@ def prompt_for_missing_vars(self, content, vars):
                 # For invalid enum input, raise immediately instead of re-prompting
                 raise ValueError(f"Variable '{var}' must be one of {enum}, got: {raw}")
             else:
-              user_input = input(f"❓ Enter value for {var} [{default}]: ") or default
+              if description:
+                print(f"{icon} {BOLD}{var}{RESET}: {description}")
+                user_input = input(f"   Enter value [{default}]: ") or default
+              else:
+                user_input = input(f"{icon} {BOLD}{var}{RESET} [{default}]: ") or default
           # Coerce and validate according to schema
           coerced = self._coerce_and_validate(var, user_input, conf)
           self.input_store.set_value(var, coerced)
diff --git a/tests/test_template_renderer.py b/tests/test_template_renderer.py
index 3b4850f..3ea5008 100644
--- a/tests/test_template_renderer.py
+++ b/tests/test_template_renderer.py
@@ -105,3 +105,102 @@ def test_render_template_with_mappings():
         config_variables, input_store, non_interactive, mappings=mappings_dot)
     rendered_content_dot = renderer_dot.render_template(content_dot, {})
     assert rendered_content_dot == "Account: 123456789"
+
+
+def test_prompt_with_description_display():
+    """Test that variable descriptions are displayed in interactive prompts with Option 4 formatting"""
+    config_variables = [
+        {"project_name": {
+            "type": "string",
+            "description": "The name of your project",
+            "default": "MyProject"
+        }},
+        {"environment": {
+            "type": "string",
+            "description": "Target deployment environment",
+            "enum": ["dev", "staging", "prod"],
+            "default": "dev"
+        }},
+        {"old_style_help": {
+            "type": "string",
+            "help": "This uses the old 'help' field",
+            "default": "test"
+        }},
+        {"no_description": {
+            "type": "string",
+            "default": "test"
+        }}
+    ]
+    input_store = "/tmp/input.json"
+    non_interactive = False
+    renderer = TemplateRenderer(config_variables, input_store, non_interactive)
+
+    # Test each variable type separately to ensure proper input handling
+
+    # Test 1: Regular variable with description (should show icon + description format)
+    content1 = "{{@ project_name @}}"
+    vars1 = {}
+    with patch('builtins.input', return_value="TestProject") as mock_input, \
+         patch('builtins.print') as mock_print:
+        result_vars1 = renderer.prompt_for_missing_vars(content1, vars1)
+        assert result_vars1["project_name"] == "TestProject"
+
+        # Check that the new format was printed (icon + bold var: description)
+        print_calls = [call.args[0] for call in mock_print.call_args_list]
+        assert any("🚀 \033[1mproject_name\033[0m: The name of your project" in call for call in print_calls)
+
+    # Test 2: Enum variable with description (should show icon + description + options)
+    content2 = "{{@ environment @}}"
+    vars2 = {}
+    with patch('builtins.input', return_value="prod") as mock_input, \
+         patch('builtins.print') as mock_print:
+        result_vars2 = renderer.prompt_for_missing_vars(content2, vars2)
+        assert result_vars2["environment"] == "prod"
+
+        # Check that description and options were printed in new format with bold
+        print_calls = [call.args[0] for call in mock_print.call_args_list]
+        assert any("🌍 \033[1menvironment\033[0m: Target deployment environment" in call for call in print_calls)
+        assert any("Options: (1) dev, (2) staging, (3) prod" in call for call in print_calls)
+
+    # Test 3: Variable with 'help' field (backward compatibility)
+    content3 = "{{@ old_style_help @}}"
+    vars3 = {}
+    with patch('builtins.input', return_value="help_test") as mock_input, \
+         patch('builtins.print') as mock_print:
+        result_vars3 = renderer.prompt_for_missing_vars(content3, vars3)
+        assert result_vars3["old_style_help"] == "help_test"
+
+        # Check that help was printed in new format with bold
+        print_calls = [call.args[0] for call in mock_print.call_args_list]
+        assert any("🔧 \033[1mold_style_help\033[0m: This uses the old 'help' field" in call for call in print_calls)
+
+    # Test 4: Variable without description (should use compact format with icon)
+    content4 = "{{@ no_description @}}"
+    vars4 = {}
+    with patch('builtins.input', return_value="no_desc_test") as mock_input, \
+         patch('builtins.print') as mock_print:
+        result_vars4 = renderer.prompt_for_missing_vars(content4, vars4)
+        assert result_vars4["no_description"] == "no_desc_test"
+
+        # Check that no description line was printed (should use inline format)
+        print_calls = [call.args[0] for call in mock_print.call_args_list]
+        # Should not contain the two-line format with description
+        assert not any(": " in call and "no_description" in call for call in print_calls)
+
+def test_variable_icon_selection():
+    """Test that appropriate icons are selected for different variable types"""
+    config_variables = []
+    input_store = "/tmp/input.json"
+    non_interactive = True
+    renderer = TemplateRenderer(config_variables, input_store, non_interactive)
+
+    # Test icon selection logic
+    assert renderer._get_variable_icon("project_name", "string") == "🚀"
+    assert renderer._get_variable_icon("environment", "string") == "🌍"
+    assert renderer._get_variable_icon("port", "integer") == "🔌"
+    assert renderer._get_variable_icon("enable_logging", "boolean") == "⚡"
+    assert renderer._get_variable_icon("api_token", "string") == "🔐"
+    assert renderer._get_variable_icon("database_url", "string") == "🗄️"
+    assert renderer._get_variable_icon("version", "string") == "🏷️"
+    assert renderer._get_variable_icon("config_path", "string") == "📁"
+    assert renderer._get_variable_icon("random_var", "string") == "🔧"