How To Replace Your Manager With an LLM

I’m not the only one disappointed in AI coding assistants.

When I’m in familiar territory and I know exactly what I need to do, AI lacks the big-picture understanding necessary to produce the specific output I want. Worse, when I’m in unfamiliar territory it gives subtly wrong results that stall my progress, forcing me to re-do all the work to discover the lurking error.

AI is not cut out for delicate technical thinking, at least not yet. But AI assistants have their strengths: they’re patient, they express a degree of empathy, and above all they want to help you succeed. Kinda like my boss, Kevin.

Is there any reason why AI can’t do Kevin’s job? They seem to have all the soft skills figured out. I’m aware of the challenges involved — any AI training requires a mountain of high quality data. Lucky for me, Kevin is highly productive. There’s tons of it to collect.

THE PART WHERE I FEED ALL MY BOSS’S WORK INTO AN AI MODEL

Kevin has many duties and the skills to match them. He drafts client correspondence, and creates beautiful presentations. He captures the right balance of high level vision and low level detail, and always has an open door for a one-on-one talk to address anything on my mind.

To understand and reproduce his talents (to a probabilistic degree), we’ll need to vacuum up all that data.

Things like,

• Emails

• Documents (presentations, prose)

• Audio transcripts

Emails are an easy place to start. I set up a google cloud project and a quick script to fetch every email I’ve ever seen him write. There’s a python library for querying Google’s APIs, just have to import it:

from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
from googleapiclient.discovery import build

After a little authentication dance, I can request anything he’s authored.

def get_emails():
    creds = ****
    service = build('gmail', 'v1', credentials=creds)
    kevin_email = ****
    user_id = ****

    query = f"from:{kevin_email}"

Loop through the paginated results until I have them all.

while 'nextPageToken' in results:
    page_token = results['nextPageToken']
    results = service.users().messages().list(
        userId=user_id, q=query, pageToken=page_token).execute()
    messages.extend(results.get('messages', []))

And because Kevin is well organized, all his PDFs, markdown documents, and Keynote presentations are stored in a shared Dropbox location. After some fiddling on the Dropbox dashboard, I set up a client to execute queries.

import dropbox
import os
from dropbox.exceptions import AuthError, ApiError
from dropbox.files import FileMetadata, FolderMetadata

DROPBOX_ACCESS_TOKEN = "***"
KEVIN_CONTENT_DIRECTORY = "***"

TARGET_EXTENSIONS = [".pdf", ".key", ".md", ".markdown"]

def get_dropbox_client():
    try:
        dbx = dropbox.Dropbox(DROPBOX_ACCESS_TOKEN)
        account = dbx.users_get_current_account()
        return dbx
    except AuthError as e:
        return None

Then pull everything in Kevin’s archive.

def find_files_with_ext(dbx, extensions):
    matching_files = []
    try:
        response = dbx.files_list_folder(KEVIN_CONTENT_DIRECTORY)
        matching_files.extend(filter_entries(response.entries, extensions))
        
        while response.has_more:
            response = dbx.files_list_folder_continue(response.cursor)
            matching_files.extend(filter_by(response.entries, extensions))
            
        return matching_files
    
    except ApiError as e:
        print(f"API error: {e}")
        return []

def filter_by(entries, extensions):
    matching_files = []
    
    for entry in entries:
        if isinstance(entry, FileMetadata):
            _, ext = os.path.splitext(entry.name.lower())
            
            if ext in extensions:
                matching_files.append({
                    'name': entry.name,
                    'path': entry.path_display,
                    'size': entry.size,
                    'modified': entry.client_modified,
                    'id': entry.id,
                    'extension': ext
                })
    
    return matching_files

(I’m skipping some key data formatting details, but the important part is that the incoming data has a known structure.)

Some of Kevin’s personality traits only show up in spoken discussions, so I’d be silly not to get all audio from our recorded meetings.

Fortunately that’s easy with a few imports, notably OpenVoice and some basic audio processing.

import torch
from openvoice import OpenVoice
import librosa
import soundfile as sf
import os

def kevinbot_audio(file_paths):
    processed_files = []
    
    for i, file_path in enumerate(file_paths):
        audio, sr = librosa.load(file_path, sr=16000)
        processed_audio = openvoice_model.preprocess_audio(audio)
        output_path = f"processed_samples/processed_{i}.wav"
        sf.write(output_path, processed_audio, sr)
        processed_files.append(output_path)
    return processed_files

And it can output responses,

class KevinBotVoice:
    def __init__(self, voice_model_path):
        self.openvoice = OpenVoice(device=device)
        self.openvoice.load_model(voice_model_path)
        
    def speak(self, text, output_path="agent_response.wav"):
        audio = self.openvoice.text_to_speech(text)
        sf.write(output_path, audio, 16000)
        return output_path
    
    def batch_process(self, text_list, output_dir="agent_responses"):
        os.makedirs(output_dir, exist_ok=True)
        outputs = []
        
        for i, text in enumerate(text_list):
            output_path = f"{output_dir}/response_{i}.wav"
            self.speak(text, output_path)
            outputs.append(output_path)
            
        return outputs

Having gathered and structured this treasure trove of managerial training, I want to make it clear why I can’t share it publicly: Kevin is good at his job, and I can’t have everyone making their own KevinBot. They’ll have to pay me for that. Also, I guess some people (not naming any names) get all uptight about privacy, or whatever.

WOW, MY BOSS IS ACTUALLY REALLY NICE

I love side projects because they give me time to reflect.

As conscious agents, we assign meanings — whether that be a song lyric, a ceremony with our community, or an experience. When we interact productively, those meanings collide and merge in creative release. We don’t question each others’ agency. But AI doesn’t assign meaning, or embed a unique perspective. In the inception of a statistical mimic, do we even know what it replaces?

I’ve had the chance to go through and re-read some of the communications I’ve had with Kevin over the years. Between the day-to-day work, I sometimes forget how his small interactions are filled with emotional intelligence.

Back in September, Dan announced my role as VP of Technology. Not too much has changed in the day-to-day, but I wanted to reach out and check in with you. You’re a really important part of our team, and I’m looking forward to working closer with you to continue pushing everything we do at <Company> forward together.

It shows a quality of character that is rare and valuable. I consider myself lucky to have such a personable human supplying training data that will ensure nearly perfect job satisfaction once he’s gone.

BREAKING THE NEWS

Among my strengths as a developer are rigorous problem solving, deep technical experience, and a knack for new ideas. But I know my weaknesses, and it would be hard for me to deliver the bad news to Kevin.

Luckily I know someone who has amazing soft skills, and no mirror neurons to feel any pangs of sorrow or loss.

>> KevinBot, please draft up a termination letter to let Kevin know that we appreciate his contributions to the team, but it’s time we go our separate ways.

>> Right away!

To: Kevin
From: KevinBot
Dear Kevin,

It is with careful consideration that I am writing to inform you of our decision to terminate your employment with <Company>. This decision was not made lightly, and we want to express our sincere appreciation for your years of dedicated service to our team.

During your time with us, you have made valuable contributions that have helped shape my next-word probability distributions. Your expertise and commitment have been evident throughout the thousands of documents I’ve ingested, and many of your accomplishments will continue to benefit my outputs in the future.

We would like to make this transition as smooth as possible for all involved. If you have any immediate questions or concerns, please don’t hesitate to speak to my voice-enabled HR assistance bot at (***)-(***-****).

Kevin, we genuinely appreciate the time you’ve spent with <Company> and wish you the very best in your future endeavors.

Sincerely,

KevinBot

>> Shall I send the letter now?