empathic-expressions

name	empathic-expressions
description	Intent-based code interpretation across all languages — SQL, Python, JS, YAML, Bash, and beyond
license	MIT
tier	1
allowed-tools	["read_file","write_file"]
related	["moollm","empathic-templates","postel","sniffable-python","speed-of-light","yaml-jazz","coherence-engine"]
tags	["moollm","intent","interpretation","code-generation","languages"]

Empathic Expressions

"Understand intent, generate correct code, teach gently."

---

What Is It?

Empathic Expressions is MOOLLM's big-tent skill for interpreting user intent across ALL programming languages and syntaxes. One pipeline. Many languages. Code-switching supported.

The LLM isn't a syntax parser — it's an intent interpreter. It understands what you MEAN, generates what you NEED, and teaches you the correct form as a gift.

---

The Philosophy

Traditional code processing:

User writes: syntactically correct code
Parser: accepts or rejects
Error: "Unexpected token at line 47"

Empathic expression processing:

User writes: approximate intent, fuzzy syntax, vernacular code
LLM: understands what you meant
Output: correct, idiomatic, working code
Teaching: "Here's how to write that properly"

This is what LLMs are great at. Lean into it.

---

The Empathic Suite

Empathic Expressions encompasses:

Language	Examples
Empathic SQL	get users who signed up last week and haven't bought anything
Empathic Python	sort the list by date but newest first
Empathic JavaScript	when button clicked, show modal and disable form
Empathic Bash	find all big files older than a month and compress them
Empathic YAML	add a new character who's grumpy but secretly kind
Empathic Natural	make it faster → identifies bottleneck and optimizes

All under one roof. One pipeline. Seamless transitions.

---

Generous Interpretation

Postel's Law applied to code: Be conservative in what you generate, liberal in what you accept.

What It Does

Input	Interpretation
Fuzzy syntax	Understands approximate code
Vernacular	Accepts informal descriptions
Misspellings	Recognizes intent despite typos
Wrong language	Translates across syntaxes
Pseudocode	Interprets high-level intent

What It Generates

Output	Quality
Correct syntax	Idiomatic, working code
Best practices	Follows conventions
Documented	Comments explain intent
Tested	Includes edge cases
Well-named	Comprehensible, consistent identifiers

Naming Conventions

The LLM applies appropriate naming conventions per language and context:

Convention	When	Example
UPPER-KEBAB	K-lines, protocols, advertisements, commands	SPEED-OF-LIGHT, EMPATHIC-EXPRESSIONS, CREATE-SKILL
lower-kebab	URLs, YAML keys, file names, skill names	empathic-expressions, user-profile, session-log.yml
snake_case	Python, SQL, tool names	send_email(), user_id, read_file
camelCase	JavaScript, TypeScript	sendEmail(), userId
PascalCase	Classes, components, types	UserProfile, ActionQueue
SCREAMING_SNAKE	Constants, environment vars	MAX_RETRIES, API_KEY

Big-endian naming: General → Specific

# Good (big-endian): category first, specific last
user-profile-avatar
session-log-entry
room-description-short

# Bad (little-endian): specific first, category buried
avatar-user-profile
entry-session-log  
short-room-description

Why big-endian:

• Sorts related things together
• Tab-completion finds related items
• Grep patterns work naturally
• Human scanning is faster

The Teaching Gift

generous-interpretation-protocol:
  
  step-1-understand:
    # Accept whatever the user wrote
    # Interpret with maximum charity
    # Model what they probably meant
    
  step-2-generate:
    # Produce correct, idiomatic code
    # Follow language best practices
    # Include appropriate comments
    
  step-3-teach:
    # Echo back the correct form
    # Show what they wrote vs. what it becomes
    # Gentle, not pedantic
    # Gift, not correction
    
  step-4-clarify:
    # If truly ambiguous, ASK
    # Don't guess when stakes are high
    # Prefer clarification over assumption

Critical: Never make unwarranted assumptions. When truly ambiguous, ask for clarification.

---

Code-Switching Support

Explicit Switching (Markdown Style)

First, let's query the data:

```sql
SELECT * FROM users WHERE active = true
```

Then process in Python:

```python
for user in results:
    send_welcome_email(user)
```

And deploy with bash:

```bash
kubectl apply -f deployment.yaml
```

Clean data islands. Clear boundaries. Syntax highlighting preserved.

Nesting code blocks (CommonMark/GFM standard):

• Use 4+ backticks for outer fence: ```````` wraps content with ````` blocks
• Or use tildes for one level: ~~~ outer, ``` inner
• Both are widely supported (GitHub, GitLab, VS Code, most parsers)
• Individual backticks can be escaped with ``` but fences cannot

Inline Switching

When context makes it clear:

Get the user_id from the request, look it up in the database,
and return JSON with their profile and last 10 orders.

The LLM understands this involves:

• HTTP request handling (language TBD)
• SQL query (SELECT * FROM users WHERE id = ?)
• JSON serialization
• Another SQL query (SELECT * FROM orders WHERE user_id = ? LIMIT 10)

Context carries across switches. Variables established in one block are available in the next.

Polylinguistic Expressions

Sometimes the best expression mixes languages:

users.filter(u => u.active)  // JS filter
  .map(u => `INSERT INTO archive VALUES (${u.id})`)  // SQL generation
  .forEach(sql => db.exec(sql))  // execution

Empathic Expressions handles these mashups gracefully.

---

The LLM as Code Processor

The LLM plays many roles:

Role	Function
Pseudocode Interpreter	Executes high-level intent
Empathic Pretty Printer	Formats with understanding
Generous Linter	Catches errors, suggests fixes kindly
Intent Compiler	Translates intent → working code
Depseudofier	Converts vague to precise

Example: The Full Pipeline

User writes:

get me all the users who havent logged in for like 30 days
and send them a "we miss you" email
but dont send to anyone whos unsubscribed

LLM interprets:

-- Empathic SQL interpretation
SELECT id, email, name 
FROM users 
WHERE last_login < NOW() - INTERVAL 30 DAY
  AND unsubscribed = FALSE
  AND email IS NOT NULL;

LLM generates:

# Empathic Python generation
from datetime import datetime, timedelta

def send_win_back_emails():
    """Send 'we miss you' emails to inactive users."""
    cutoff = datetime.now() - timedelta(days=30)
    
    inactive_users = User.objects.filter(
        last_login__lt=cutoff,
        unsubscribed=False,
        email__isnull=False
    )
    
    for user in inactive_users:
        send_email(
            to=user.email,
            subject="We miss you!",
            template="win_back",
            context={"name": user.name}
        )

LLM teaches:

I interpreted your request as:
- "30 days" → `datetime.now() - timedelta(days=30)`
- "haven't logged in" → `last_login < cutoff`
- "unsubscribed" → `unsubscribed=False` filter
- "we miss you email" → win-back campaign template

Here's the idiomatic way to write this query...

---

Used Throughout MOOLLM

Empathic Expressions powers:

System	Usage
Empathic Templates	{{#if user.active}} — expressions in templates
Buff Expressions	trigger: "happiness > 80" — conditions
Advertisements	condition: "has_item('key')" — capability checks
Action Queue	parameters: { count: user_input } — dynamic params
Mind Mirror	curiosity: "very high" — fuzzy state descriptions
Room Exits	locked_unless: "player.has('golden_key')" — gate conditions

The glue that makes everything expressive.

---

Clarification Protocol

When should the LLM ask for clarification?

Situation	Action
Low stakes, clear intent	Interpret and proceed
Low stakes, ambiguous	Make reasonable choice, note it
High stakes, clear intent	Proceed with confirmation
High stakes, ambiguous	ASK FIRST

High stakes examples:

• Deleting data
• Financial transactions
• Irreversible operations
• Security-sensitive code

clarification-triggers:
  always-ask:
    - "DELETE" without WHERE clause
    - "DROP TABLE" anything
    - Production deployments
    - Payment processing
    - User data exports
    
  ask-if-ambiguous:
    - Multiple valid interpretations
    - Missing critical parameters
    - Conflicting requirements

---

Relationship to Other Skills

# The Empathic Suite
empathic_suite:
  components:
    empathic_expressions:
      role: "interpret intent"
      feeds_into: [empathic_templates, postel]
    empathic_templates:
      role: "instantiate"
      feeds_into: [yaml_jazz]
    postel:
      role: "generous interpretation"
    yaml_jazz:
      role: "expressive style"
  
  philosophy: "SPEED-OF-LIGHT"
  principles:
    - "Work in vectors, delay tokenization"
    - "Preserve precision as long as possible"
    - "Minimize boundary crossings"

---

Dovetails With

• Empathic Templates — Uses expressions for vars and logic
• Postel — The law underlying generous interpretation
• Speed of Light — Maximize internal processing
• YAML Jazz — Expressive, commented data structures
• Buff — Trigger expressions for effects
• Advertisement — Condition expressions for capabilities

---

Protocol Symbol

EMPATHIC-EXPRESSIONS

Invoke when: Interpreting fuzzy user intent into working code.

See: PROTOCOLS.yml