Human++ — A color scheme for the post-artisanal coding era

The Philosophy

Traditional syntax highlighting treats all code equally. Human++ doesn't.

Q

Quiet Syntax

Everyday code — keywords, strings, functions — uses muted colors that fade into the background. You've seen this code a thousand times.

!

Loud Diagnostics

Errors, warnings, and human markers demand attention with vibrant, saturated colors. When you see color, it means something.

>

Terminal Exception

Terminal output is intentional — you typed it. Terminals get loud colors for normal text, quiet for bright. Inverted from the editor.

Theme in Action

See Human++ across different languages. Notice how syntax stays quiet while markers pop.

interface User {
  id: string;
  email: string;
  createdAt: Date;
}

// !! Critical: rate limiting depends on this cache key format
async function getUser(id: string): Promise<User | null> {
  const cached = await redis.get(`user:${id}`);
  if (cached) {
    return JSON.parse(cached);
  }

  // ?? Should we add retry logic here?
  const user = await db.users.findUnique({ where: { id } });

  if (user) {
    // >> See config.ts for TTL settings
    await redis.set(`user:${id}`, JSON.stringify(user), 'EX', 3600);
  }

  return user;
}

from dataclasses import dataclass
from typing import Optional
import asyncio

@dataclass
class Order:
    id: str
    total: float
    items: list[str]

# !! Critical: this runs in production every 5 minutes
async def process_pending_orders() -> int:
    orders = await db.fetch_pending()
    processed = 0

    for order in orders:
        # ?? Not sure if we need to handle partial refunds here
        if order.total > 10000:
            await flag_for_review(order)
            continue

        # >> See payment_gateway.py for Stripe integration
        result = await charge_customer(order)
        if result.success:
            processed += 1

    return processed

use std::collections::HashMap;

#[derive(Debug, Clone)]
struct Config {
    max_retries: u32,
    timeout_ms: u64,
}

// !! Critical: this is called on every request
pub fn validate_token(token: &str) -> Result<Claims, AuthError> {
    let parts: Vec<&str> = token.split('.').collect();

    if parts.len() != 3 {
        return Err(AuthError::MalformedToken);
    }

    // ?? Should we cache decoded tokens?
    let claims = decode_jwt(parts[1])?;

    // >> See crypto.rs for signature verification
    verify_signature(token, &claims.key_id)?;

    Ok(claims)
}

Diagnostics in Action

Errors and warnings pop. Syntax stays quiet. Problems are impossible to miss.

Explorer

▼ src 2 1

📄 user.ts 2

📄 api.ts 1

📄 cache.ts

▶ utils

📄 temp.ts

interface User {
  id: string;
  name: string;
}
const user: User = getUser();
user.name = null;Type 'null' is not assignable to type 'string'
if (user) {Condition always true
  console.log(user.id);
}

Human Intent Markers

Lightweight punctuation markers that flag human judgment in comments.

!!

Attention

Pay attention here. Human decision that matters.

??

Uncertainty

I'm not confident. Please review this.

>>

Reference

See related code or documentation.

// Regular comment stays calm (base03)
 
async function processOrder(order: Order) {
  // !! Critical: legacy billing depends on this exact format
  const invoice = formatLegacy(order);
 
  if (order.total > 10000) {
    // ?? Not sure this handles international tax correctly
    await flagForReview(invoice);
  }
 
  // >> See billing/tax.ts for the tax calculation logic
  return finalize(invoice);
}

VS Code & Cursor

Install the extension for the complete Human++ experience.

# Install from marketplace
$ code --install-extension fielding.human-plus-plus

# Or search "Human++" in the extensions panel

🎨

Color Theme

Quiet syntax highlighting with loud diagnostics. The full Human++ palette for your editor.

!!

Intent Markers

Comments with !! ?? >> get highlighted backgrounds.

⚠

Inline Diagnostics

Errors and warnings appear as inline badges at the end of lines. No hovering required.

VS Code Marketplace Open VSX (Cursor)

The Palette

Cool charcoal grays, warm cream text, 24 colors in the Base24 system.

Grayscale (base00–07)

Loud Accents — Diagnostics & Signals (base08–0F)

Quiet Accents — Syntax & UI (base10–17)

Other Apps

Human++ works with tinty and standard Base24 tooling.

# Clone the repo
$ git clone https://github.com/fielding/human-plus-plus

# Build all theme files from palette.toml
$ make build

# Apply with tinty
$ tinty apply base24-human-plus-plus

Ghostty

ghostty/config

Vim/Neovim

vim/colors/

iTerm2

iterm/

Sketchybar

sketchybar/

JankyBorders

borders/

skhd

skhd/

Shell

base24/