VibeCoding Logger

VibeCoding Logger is an "AI-native" logging solution designed for the Vibe Coding methodology (where humans provide natural language instructions and AI generates code).

Unlike traditional loggers meant for human reading, VibeCoding Logger focuses on creating high-quality, structured data packages (JSON) that maximize information for LLMs. It allows developers to act as "diagnosticians" by providing rich context, stack traces, and direct instructions to the AI (the "surgeon").

Key conceptual pillars include:

• Structured JSON Output: Optimized for AI parsing.
• Rich Context: Captures operations, variable states, and correlation IDs.
• Human-to-AI Communication: Dedicated fields for human notes and AI tasks.
• Environment Capture: Automatically records runtime details (OS, language versions) for reproducibility.

The vibelogger library is fully thread-safe, making it suitable for concurrent or multi-threaded applications.

import threading
from vibelogger import create_file_logger

logger = create_file_logger("multi_threaded_app")

def worker(worker_id):
    logger.info(
        operation="worker_task",
        message=f"Worker {worker_id} processing",
        context={"worker_id": worker_id}
    )

# Safe to use across multiple threads
threads = [threading.Thread(target=worker, args=(i,)) for i in range(10)]
for t in threads:
    t.start()

To link related operations across your application, provide a correlationId when creating the logger. All subsequent logs from that instance will share the same ID, making it easy for an AI to reconstruct a sequence of events.

// Use same correlation ID across related operations
const correlationId = `request-${Date.now()}`;
const logger = createLogger({ correlationId });

await logger.info('request_start', 'Processing API request');
await logger.info('auth_check', 'Validating credentials');
await logger.info('business_logic', 'Executing core logic');
await logger.info('request_end', 'Request completed');

// All logs will have the same correlation_id

The logException method is designed to handle both standard Error objects and arbitrary values thrown in JavaScript (like strings or numbers). It normalizes these into a consistent ErrorInfo structure to ensure the JSON log remains predictable.

• If an Error object is passed, it extracts message, stack, and name.
• If a primitive is passed (e.g., throw 'error'), it converts the value to a string and sets the name to UnknownError.

logException(operation: string, error: Error | unknown, options?: LogOptions) {
  const errorInfo = this.extractErrorInfo(error);
  // ... normalization logic
}

private extractErrorInfo(error: unknown): ErrorInfo {
  if (error instanceof Error) {
    return { message: error.message, stack: error.stack, name: error.name };
  }
  return { message: String(error), stack: undefined, name: 'UnknownError' };
}

To integrate VibeCoding Logger into your AI-driven workflow (e.g., using Claude Code), add the following instructions to your project's CLAUDE.md file. This tells the AI to use the library and where to find debugging data.

### Project Logging
* Use vibelogger library for all logging needs
* vibelogger instruction: https://github.com/fladdict/vibe-logger/blob/main/README.md
* Check ./logs/<project_name>/ folder for debugging data when issues occur

For long-running processes where you want to avoid Out-Of-Memory (OOM) issues, disable in-memory log storage by setting keep_logs_in_memory=False in the VibeLoggerConfig.

from vibelogger import VibeLoggerConfig, create_logger

# For long-running processes - disable memory storage
config = VibeLoggerConfig(
    log_file="./logs/production.log",
    keep_logs_in_memory=False,  # Don't store logs in memory
    auto_save=True
)
logger = create_logger(config=config)

Install the vibelogger package using npm to start using AI-native logging in your Node.js/TypeScript project.

npm install vibelogger

Install the library based on your target language:

Python

pip install vibelogger

TypeScript/Node.js

npm install vibelogger