How to Build a Fictional 1980s Late-Night "Ghost-Line" Radio Show Simulator Using Claude 3.5 Sonnet and Python

The Vibe of Late-Night AM Radio

Before the internet became our collective repository of the bizarre, there was late-night AM radio. If you grew up or have a soft spot for the 1980s, you probably remember the atmospheric magic of tuning into low-frequency broadcasts in the dead of night. Amidst the white noise, crackle, and signal drift, callers would dial in to share highly suspect, deeply unsettling tales of UFO sightings, local cryptids, and phantom hitchhikers, all moderated by a sleepy, baritone host.

We are going to recreate this nostalgic, eerie experience. Using /platforms/claude to dynamically generate the dialogue of both the host and the paranoid callers, and a simple Python audio framework to play background AM static, we will build a local, interactive "Ghost-Line" radio show simulator that runs directly in your terminal.

Designing the Architecture

Our simulator needs three main components to capture the late-night aesthetic: 1. The Caller Engine: A system prompt that forces Claude to think and write like a bizarre array of 1980s characters calling from phone booths, desolate highways, or wood-panelled basements. 2. The Host: A soothing, slightly skeptical anchor who keeps the show moving. 3. The Static Generator: A background audio thread that loops a genuine AM radio static track, dipping in volume when the characters speak.

Let’s get coding.

Step 1: Setting up the Claude Prompt

To make our callers feel authentic, we need to bypass modern LLM conversational patterns. Claude shouldn't sound helpful, polite, or structured. We want stuttering, colloquialisms, 1980s slang, and a mounting sense of dread.

If you want to tweak this prompt structure later for different genres (like a 1990s conspiracy show or a retro sports call-in), you can use our /prompts to dial in the persona parameters.

Here is the system prompt we will inject into our Python app:

`text You are the engine for "W-GHOST 104.2 AM", a fictional late-night call-in radio show set in October 1986. You will generate dialogue for either the host (Arthur Pendelton, who is calm, warm, and slightly tired) or a random caller.

Callers must fit the 1980s aesthetic: calling from payphones, using slang of the era ("radical", "man", "wild"), and describing uncanny, ambiguous paranormal encounters (not generic Hollywood monsters, but weird lights, static on their television, unexplainable structures in the pine barrens, or voices on the baby monitor).

Output your response strictly as a JSON object with this structure: { "speaker": "Host" or "Caller (Name)", "dialogue": "The text to be spoken", "ambience_cue": "distant_siren" or "payphone_beeps" or "none" } Do not include any other markdown formatting outside of this JSON. `

If you find yourself getting formatting issues or API connection drops while running this, jump over to our /platforms/claude/articles to resolve your API pipeline errors.

Step 2: Writing the Python Simulator

We will use the official anthropic Python SDK to handle our generation, and pygame to manage our atmospheric sound design. Make sure you have your API key ready.

First, install the necessary libraries:

`bash pip install anthropic pygame `

Now, let's write the core loop. To run this successfully, find a short .mp3 or .wav file of radio static or white noise online and save it in your project directory as static.mp3.

`python import os import time import json import pygame from anthropic import Anthropic

Initialize sound engine pygame.mixer.init() static_channel = pygame.mixer.Channel(0)

try: static_sound = pygame.mixer.Sound("static.mp3") static_channel.play(static_sound, loops=-1) static_channel.set_volume(0.2) # Low background crackle except FileNotFoundError: print("Note: static.mp3 not found. Running in silent mode.")

client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

conversation_history = []

def get_next_radio_segment(): system_prompt = """You are the engine for 'W-GHOST 104.2 AM', a 1986 radio show. Return ONLY a JSON object with 'speaker', 'dialogue', and 'ambience_cue'.""" response = client.messages.create( model="claude-3-5-sonnet-20241022", max_tokens=300, system=system_prompt, messages=conversation_history + [{"role": "user", "content": "Generate the next segment of the show. If a caller just finished, the host should respond. If the host just finished, introduce a new caller with a creepy story."}] ) content = response.content[0].text data = json.loads(content) return data

print("=== TUNING INTO 104.2 W-GHOST AM [OCTOBER 1986] ===\n") time.sleep(2)

Initialise history with a starting prompt conversation_history.append({"role": "user", "content": "Start the radio broadcast. Arthur should introduce the show and open the phone lines."})

try: for _ in range(5): # Run a mini-episode of 5 exchanges segment = get_next_radio_segment() # Add to history to keep the narrative coherent conversation_history.append({"role": "assistant", "content": json.dumps(segment)}) # Visual flair: print character by character to simulate old CRT terminals print(f"[{segment['speaker']}]: ", end="", flush=True) for char in segment['dialogue']: print(char, end="", flush=True) time.sleep(0.04) print("\n") # Dynamic audio ducking if segment['ambience_cue'] != "none": print(f" [SFX Cue]: {segment['ambience_cue']} \n") time.sleep(3) # Let the player digest the dialogue except Exception as e: print(f"\nAn error occurred: {e}") finally: static_channel.stop() print("\n=== SIGNAL LOST. ONLY STATIC REMAINS ===") `

Step 3: Immersing Yourself in the 1980s Night

When you run this script, something fascinating happens. The structural memory of Claude 3.5 Sonnet allows it to weave incredibly atmospheric tales. Arthur the host will gently prod callers with questions like, "And you're sure this wasn't just the high-beams of a passing logging truck, Gary?" while the callers defend their sanity with increasingly bizarre details about silent helicopters or glowing occurrences in their back gardens.

To elevate this experiment further, you could: Hook up a local Text-to-Speech (TTS) engine* (like Coqui or your OS's native voices) to read the dialogue aloud, complete with a low-pass filter to simulate telephonic and radio frequency limitations. Introduce random "signal loss" events*, where the text printed to the console becomes scrambled with random ASCII symbols as the background static volume surges.

The Wrap-Up

Building narrative simulators like this shows that generative AI doesn’t just have to be about enterprise productivity or summarising corporate PDFs. Sometimes, the most satisfying projects are the ones that let us use state-of-the-art models to build weird, nostalgic time machines. Turn off your lights, fire up your terminal, and see what is waiting on the other side of the dial.