Deterministic vs Non-Deterministic in LLM Models

// Conceptual model of deterministic computation
function computeProbabilities(prompt: string): Map<string, number> {
  // Neural network math - ALWAYS produces same output for same input
  return new Map([
    ["the", 0.35],
    ["a", 0.25],
    ["an", 0.15],
    // ... thousands more tokens
  ]);
}

// Simplified sampling logic
function sampleNextToken(
  probabilities: Map<string, number>,
  temperature: number
): string {
  if (temperature === 0) {
    // DETERMINISTIC: Always pick highest probability token
    return getHighestProbToken(probabilities); // "greedy decoding"
  } else {
    // NON-DETERMINISTIC: Randomly sample based on adjusted probabilities
    const adjusted = applyTemperature(probabilities, temperature);
    return randomSample(adjusted); // involves randomness!
  }
}

// Example: Anthropic API call
const response = await anthropic.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 100,
  temperature: 0,        // ← DETERMINISTIC (greedy)
  messages: [{ role: "user", content: "What is 2+2?" }]
});

// temperature: 0   → Same answer every time
// temperature: 0.7 → Creative variation
// temperature: 1.5 → High randomness (can be incoherent)

// .claude/settings.json
{
  "hooks": {
    "PostToolUse": [
      {
        // Always run after Claude edits TypeScript files
        "matcher": "Edit(*.ts)",
        "command": "npx prettier --write $CLAUDE_FILE_PATH && npx eslint --fix $CLAUDE_FILE_PATH"
      },
      {
        // Always typecheck after any .ts modification
        "matcher": "Edit(*.ts)",
        "command": "npx tsc --noEmit"
      }
    ],
    "PreToolUse": [
      {
        // Block writes to production configs
        "matcher": "Write(production.*.json)",
        "command": "echo 'BLOCKED: Cannot modify production configs' && exit 1"
      }
    ]
  }
}

# Run 1
claude "Create a function to validate email"

# Output might be:
function validateEmail(email: string): boolean {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

# Run 2 (same prompt)
claude "Create a function to validate email"

# Output might be:
const isValidEmail = (input: string): boolean => {
  const emailRegex = /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/;
  return emailRegex.test(input);
};

<!-- CLAUDE.md in your project root -->
# Code Standards (DETERMINISTIC RULES)

## TypeScript Conventions
- ALWAYS use `function` keyword, never arrow functions for top-level
- ALWAYS use explicit return types
- ALWAYS use `interface` over `type` for object shapes
- Variable naming: camelCase, descriptive, no abbreviations

## File Structure
- One component per file
- Tests in `__tests__/` directory
- Naming: `ComponentName.tsx`, `ComponentName.test.tsx`

## Error Handling
- ALWAYS use custom error classes
- ALWAYS include error codes
- Pattern: try/catch with typed errors

// settings.json - GUARANTEED execution
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit(*.tsx)",
        "command": "npm run lint:fix && npm run typecheck"
      }
    ]
  }
}

{
  "permissions": {
    "allow": [
      "Read",
      "Write(src/**)",
      "Bash(npm run:*)",
      "Bash(git diff)",
      "Bash(git status)"
    ],
    "deny": [
      "Write(.env*)",
      "Write(*.config.js)",
      "Bash(rm *)",
      "Bash(git push *)",
      "Bash(sudo *)"
    ]
  }
}