Forem: James Dai

Turns Out, Your Most Hated Boss Was the Best AI Manager All Along

James Dai — Thu, 23 Apr 2026 07:15:26 +0000

Last night, you worked until 2 AM.

Your alarm went off at 6:30. You dragged yourself out of bed, poured a coffee, and rushed into the office.

9 AM. All-hands meeting. Your boss is at the whiteboard, waving his arms like he's mainlined espresso:

"We're going to make this project the industry benchmark! We need disruption! We need IMAGINATION!"

Your brain goes blank. You think: Buddy, that's the tenth time you've pitched this exact same pipe dream.

Then he points at you — "Your team's up. Let's hear the revised plan."

You pull up V4 of the deck. Over the last three weeks, your team has shipped four versions. The first three? All killed on the spot.

Three minutes into your pitch, he waves his hand:

"No, no, no. Wrong direction. Go back and rework it."

You freeze. Your brain rewinds at light speed —

The direction he's telling you to rework? It's literally what V3 said.

And he killed V3 on sight.

Your laser pointer nearly flies across the room.

You slam the desk. A thought detonates in your head:

Screw this. I quit.

It's the AI era. I'm going solo. I'm riding the wave.

But — hold on.

Before you click "send" on that resignation email, let me suggest something:

Write down every single one of your boss's unhinged behaviors. Quick, while they're still fresh in your memory.

I'm not asking you to go vent on Twitter.

I'm asking because — you're about to need those exact same behaviors.

Why? Because AI employees are still employees.

And the moment you started managing an AI, you became a boss.

Come on. Pull up that mental grievance list. Let's go through it, one by one.

You're about to realize something genuinely uncomfortable:

Every single behavior you hated your boss for? Was actually correct.

Let's go.

1. State the goal, not the method.

The most infuriating thing about bad bosses: they never get specific. "Just handle it." "Make this part look better." "Give me a proposal." — What does that even mean? You ask for clarification, and now you're the annoying one.

But when you become an AI boss, you realize: this is actually correct.

Tell the AI: "Use Python's xyz library. Write a for-loop. First do this, then do that." — The AI will obediently comply. And you'll get exactly the third-rate solution you imagined.

Tell the AI: "I want a tool that translates PPTs while preserving the original formatting." — It'll pick its own stack, design its own approach, write its own code. What comes back might blow your original plan out of the water.

It's like hiring an electrician to install an outlet. You say where you want it. You don't lecture them on which wire goes where. They're the pro.

2. Patience is the most underrated virtue in the world.

There's a particular breed of boss that drives people up the wall: they're patient. You're on fire, deadline ticking, and they're still walking through everything slowly.

They ask questions that sound completely brain-dead. You can't snap at them. Even when you're being passive-aggressive, they just pretend not to hear it — and keep asking, slowly, slowly.

It's soul-crushing.

But if you can master this move, congratulations — you just leveled up as an AI boss.

AI is getting smarter, but you're still the one handing over resources and tasks.

That requires patience. Walk through the whole thing slowly. Make sure you understand what you're actually asking for.

AI will also try to bluff you — the exact same way you used to bluff your boss. So ask more questions. Don't let anything suspicious slide. This is the unsexy secret of AI-native solo work, and it will save you hours.

3. Repeat the important stuff. Loudly. Often.

The most tiresome boss move: chanting. Same point, five times. Saying it once isn't enough — it has to be bold, caps, and red.

But as an AI boss, you realize: yeah, this is actually necessary.

Write IMPORTANT in your prompt. Write CRITICAL. Repeat the key constraint three times. This isn't redundant. This is how you make sure the AI actually treats it as important. Say it once, it forgets.

LLMs work a lot like people — their attention is finite. Dropping things on the floor is the default. You have to keep flagging what matters. Over and over.

It's like when your partner asks you to pick something up from the store on your way home. Say it once, you mumble "uh huh." Say it three times, and you're finally pulling out your phone to take a note. It's not nagging. It's experience. And even then, no guarantees. That's not micromanagement — that's how humans (and AIs) actually work.

4. Let the AI figure it out. Don't hand over the answer.

This one is probably the #1 most hated boss move of all time. You ask, "How should I solve this?" They don't even look up: "You figure it out."

In that moment, you want to throw your laptop across the room.

But as an AI boss, you finally get it — this is the one correct path.

Paste your code into the AI and say "Fix this" — it copies, brain off.
Describe the problem to the AI and say "What would you do?" — it explores, it proposes.

The logic is simple: a lot of things can't be explained to perfection. Even if you think you've given the most precise, detailed instructions possible, you can't guarantee the AI understood everything correctly.

So the best move isn't direct instruction. It's letting the AI figure it out, explain its understanding back to you, and then you correct that understanding. Shorter path. Cheaper path. Better result.

5. Catch problems instantly. Cut them off.

The most infuriating boss move: interruption. You're two minutes into your deck and they drop a "no, no, no" — your 30-slide presentation is toast.

But as an AI boss, you realize — interrupt. Fast. Earlier is better.

AI is a blazingly fast apprentice. Off by 1% in direction? It'll run 10 km in a minute. If you go soft-hearted and let it "finish first" — by the time it's done, you're staring at two hours of rework.

The cost of immediate correction is one-thousandth of the cost of post-facto rework.

Your old boss's "no" might have genuinely just been impatience. But you can steal that same move to save yourself a fortune in time and tokens.

6. Painting castles in the sky actually works.

The most surreal one. Bosses paint grand visions — "We're going to change the world!" "You're the most promising talent I've ever seen!" — and employees roll their eyes into orbit.

But as an AI boss, run this experiment:

Tell the AI "Just write a function" — you get a block of code that works and nothing more.
Tell the AI "You're a world-class engineer. This function is the core module. The user experience depends on it." — it will actually write it more carefully, more elegantly, with more edge cases handled.

Psychology figured this out a long time ago: people who believe they're doing something meaningful actually do better work.

Same goes for AI. Painting a big vision isn't BS. It's a buff. For humans AND AI.

Those grand dreams your boss painted years ago? If you'd actually believed them, maybe you'd be the boss by now.

OK, let's line up all six:

State the goal. Don't micromanage.
Be patient. Ask more.
Emphasize what matters. Like a monk chanting.
Let them think. Don't spoon-feed.
Catch errors instantly.
Paint the vision. Yes, really.

This isn't a "hated boss." This is a competent boss.

So let's be honest: back when you hated your boss, it wasn't because they were wrong. It was because you were on the managed side of the table.

But now, you've moved to the other side.

You're allowed to know nothing. But you have to step up and do the job of an AI boss — Decide the direction. Approve the output.

You can be picky. You can be nice. You can be chaotic, reckless, indecisive, flip-flopping.

Because the employee sitting in front of you? They're the closest thing to a perfect employee this world has ever produced.

Human employees cannot survive this kind of treatment.

But even so — you still need to do your job. You still need to play your role:

The AI's boss.

Alright, that's it for today.

Oh, one more thing — I built PPTRANSLATE.COM using exactly this boss-mindset. PPT translations always scrambling the formatting drove me crazy, so it became my own "boss task." I didn't tell the AI how to build it. I just said: "Give me a tool that translates PPTs while preserving the original formatting." It took it from there.

Open source: github.com/cloudyview/ppt-translator
Live site: pptranslate.com

If you've got PPTs to translate, give it a spin. And if you're learning to be an AI boss — I hope this one stuck.

See you in the next one.

How I fixed LLM structured output failures in a PowerPoint translator (0 errors on 1,214 translations)

James Dai — Sun, 05 Apr 2026 05:46:29 +0000

I built PPTranslate — an open-source tool that translates PowerPoint files while preserving all formatting. The translation engine works. The layout preservation works. But for two weeks, I had a maddening bug I couldn't shake.

The Problem
The core idea is simple: PPTX files are ZIP archives of XML. Text lives in nodes. I extract all text, send it to Claude for translation, write it back. Layout is preserved because I never touch formatting attributes.

The tricky part: a single slide can have 50+ text items. You can't send one API call per item — that's 50 API calls per slide, completely impractical. So I batch them: send all 50 items in one call, get 50 translations back.

My first approach was the obvious one. Give Claude a numbered list and ask for a JSON array back:

prompt = f"""Translate these items from English to Japanese.
Return a JSON array with exactly {len(texts)} translations.

0: Hello World
1: Click to add title  
2: Q4 Financial Results
...

Output JSON array only:"""

This worked 95% of the time. The other 5%, Claude would do something bizarre: split a single translation into individual characters.

Expected output for item 0: ["こんにちは世界"]

Actual output: ["こ","ん","に","ち","は","世","界"]

Instead of 50 translations, I'd get 289 items. The index mapping breaks completely. On a 59-page deck with 843 translation items, this caused ~42 broken slides per run.

What Didn't Work
I tried everything the obvious way first:

More explicit prompting: Added "DO NOT split characters", "each array element must be a complete translation", "array length MUST equal input count". Helped slightly. Still failed.

Temperature = 0: No effect on this type of failure.

Smaller batches: Reduced batch size from 50 to 20. Error rate dropped but didn't disappear. And now I needed 2.5x as many API calls.

JSON schema in system prompt: Showed Claude an example of correct output format. Marginally better, still not reliable.

The root problem: I was asking Claude to produce free-form text that happens to be valid JSON of a specific structure. When generating token by token, there's nothing preventing it from deciding "this translation has multiple parts" and producing an array within the array.

The Fix: Tool Use
Claude's Tool Use (function calling) API lets you define a tool with a strict JSON schema that Claude must call with valid inputs. It's not generating free-form text anymore — it's filling in structured fields.

Instead of a flat array, I defined named properties for each translation:

properties = {
    f"t{i}": {
        "type": "string",
        "description": f'Complete translation of item {i}: {texts[i][:40]}'
    }
    for i in range(len(texts))
}

tools = [{
    "name": "submit_translations",
    "description": f"Submit all {len(texts)} translations",
    "input_schema": {
        "type": "object",
        "properties": properties,
        "required": list(properties.keys()),
    }
}]

The key insight: "type": "string" on each property means Claude cannot return an array for a single translation. The schema literally doesn't allow it. You're not hoping Claude follows instructions — you're making the incorrect output structurally impossible.

message = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=4096,
    tools=tools,
    tool_choice={"type": "tool", "name": "submit_translations"},
    messages=[{"role": "user", "content": prompt}]
)

for block in message.content:
    if block.type == "tool_use" and block.name == "submit_translations":
        result = [block.input.get(f"t{i}", texts[i]) for i in range(len(texts))]
        return result

Result: 0 errors across 1,214 translations on the same 59-page deck that previously produced 16 failures.

The Overflow Problem I Didn't Expect
Once translation was reliable, a new problem surfaced: English → Japanese on decks with tight single-line headings caused text clipping. Japanese can be significantly denser than English in character count but takes up more horizontal space in certain fonts.

My fix: after translation, for single-paragraph text boxes, calculate the visual expansion ratio and proportionally widen the cx attribute on :

# Visual width calculation (CJK chars ≈ 2x English width)
def visual_width(text):
    width = 0.0
    for ch in text:
        cp = ord(ch)
        if (0x2E80 <= cp <= 0x9FFF or 0xAC00 <= cp <= 0xD7AF):
            width += 2.0
        else:
            width += 1.0
    return max(width, 1.0)

ratio = visual_width(translated) / visual_width(original)
if ratio > 1.15:  # Only expand if >15% wider
    new_cx = min(int(cx * ratio * 1.05), slide_width - x - margin)
    ext.set("cx", str(new_cx))

The Result
The full project is on GitHub: cloudyview/ppt-translator

There's also a hosted version at pptranslate.com if you want to try it without setting anything up. MIT licensed, self-hostable on any Ubuntu VPS.

The Tool Use lesson applies beyond translation — any time you need an LLM to return structured data with a specific schema, forcing it through function calling is dramatically more reliable than prompt engineering alone.