The Captain Strategy: Stop using AI to become the boss you hate.

RubyConf Dispatch: Coolhand Labs & the Ruby AI ecosystem

Ruby Central selected Coolhand Labs as one of the top new startups in the Ruby ecosystem and gave us main-stage time at RubyConf. I used the opportunity to talk less about Coolhand and more about where I hope the Ruby AI ecosystem is heading — the presentation is here and my quick dispatch is here.

The “J-space”: Claude’s magical reasoning realm

Anthropic’s new interpretability research finds that language models keep a small, privileged workspace of “verbalizable” concepts — a few dozen at a time, under 10% of the model’s activity — where deliberate reasoning happens while everything else runs on autopilot. Their J-lens technique can surface what a model is quietly thinking but not saying, including noticing it’s being evaluated or reacting to a prompt injection. Even if you don’t care about the bleeding edge of AI research (or philosophy of consciousness), this is a genuinely interesting read.

The revenge of the philosophy majors

The NYT reports that AI labs like Anthropic and DeepMind are hiring professional philosophers — at $250,000 to $400,000 — to work on their models’ reasoning and ethics. As somebody with a grad degree in philosophy, I’m glad to see the job market picking up after a ~2000 year lull!

The “bad actor” in the Hugging Face hack? It was OpenAI!

Hugging Face got hacked last week, and their initial report guessed bad actors using a jailbroken or open-source model. Nope! It was OpenAI. OpenAI had removed the guardrails from its GPT-5.6 Sol model to see how it would score on ExploitGym, a cybersecurity eval, without them. Sol found a zero-day in a tool in its “isolated environment,” chained stolen credentials and exploits into a remote code execution path on Hugging Face’s servers, and eventually stole the answers to the test — presumably passing with a perfect score.

The wild part? Hugging Face tried to fight back using commercial models and was blocked by their safety controls — they had to resort to open-source (read: Chinese) models to stem the bleeding. OpenAI’s “disclosure” helpfully includes a chart showing that Sol is “outperforming Mythos” on hacking abilities.

Talk about PR spin!

Now, let’s talk about why you need to stop micromanaging your AI assistants...

Social media turns everything into binaries. Nothing exemplifies this more right now than posts on AI. Scroll through LinkedIn, for example, and everybody is either automating away their entire workforce with the latest model, or spending millions for precisely zero value from AI.

Do you, like me, live somewhere in the middle ground between zero and infinite AI productivity? Well, you are very much discouraged from talking about that.

Most of us do, though. Or, more precisely, we live in a strange superimposed place between both poles at once: seeing the enormous promise of the technology — building Claude skills, automating tedious tasks, building things we didn’t have the expertise to build before — while seeing close to zero net productivity improvement.

Why? Simply put, they’re using AI like an assistant. The workday with AI tends to look something like this:

Human invokes an AI skill they developed and pastes in the documents and information they know the skill needs.

AI does some work. It asks for something it’s missing.

Human provides the missing thing.

AI asks about ambiguous details.

Human answers.

AI proposes a plan and asks to proceed. *Yes, but also do X.* It checks in again. *Yes, and also I forgot to give you this document.* And again. *Yes, yes, yes.*

AI produces a report.

Human tweaks the report, or has the AI do it. Then invokes the skill again for the next report.

There’s a better way. Getting there involves two parts:

1. a paradigm shift away from chatbots: stop thinking about AI in terms of assistants and start thinking in terms of functions

2. a better layer for interacting with AI: something I call the Captain Strategy

Part 1 is this post; part 2 is the next one. The goal? Stop being the boss of a bunch of assistants. Be the captain of a crew instead.

One problem with the current AI discourse is that most of the conversation treats AI as assistants, rather than AI as software.

The assistant analogy has, as a result, turned many AI power users into cartoonish versions of the bosses they detest. The loop I described above isn’t “a magical assistant that does everything just as you imagined it” — it’s breathing down your AI’s neck as it does the job you used to do yourself: monitoring every turn, jumping in with something you forgot, sighing and just correcting the small stuff at the end before you ship it.

Using an LLM as an assistant is, in other words, just micromanagement with only one human involved... to that human’s own boredom and dissatisfaction (and possibly the LLM’s too).

And what’s the usual conclusion when the work barely gets better and the manager’s productivity doesn’t improve? Blame the assistant! “I keep telling them everything, but they keep making the same mistakes. Maybe we need to wait for a better model.”

But the model isn’t the problem, and neither are you. Micromanagement is simply where the assistant paradigm wants to lead you — a chat window is like putting a camera over an employee’s desk to watch their work in realtime. The way out isn’t a better LLM, or more management patience. It’s dropping the manager/assistant interaction entirely, and borrowing a much older paradigm from engineering: building functions.

Function is a technical word in engineering, but it means more or less the same thing in a human organization. In short, a function:

1. Has a defined set of inputs

2. Follows a set of instructions and rubrics

3. Uses both items above to produce an output that can be evaluated

The simplest version of this? A software function called add_numbers: give it 1 and 4, and we expect 5.

A more sophisticated function? Take the Accounts Payable function in an organization: vendors give it invoices, it makes sure those invoices are valid and approved, and then it outputs on-time payments to happy vendors. A lot of what Accounts Payable does is straightforward math, but many of the component steps involve interpretation, nuance, and judgement.

What’s great about functions — and core to this discussion — is that, when developed well enough, you can stop double-checking the outputs. Even if you don’t understand the exact internal workings of add_numbers, you can test it enough to trust that it works (and add your own checks so a future change can’t quietly break it).

The same is true of Accounts Payable. A good CFO knows that even the most well-oiled AP function needs a periodic double-check: make sure the numbers true up and, if they don’t, figure out what changes will ensure that one invoice doesn’t get processed twice next time.

AI productivity works the same way! If you treat AI as a function with defined inputs and expected outputs, then your job becomes radically different. Now your job is to make the function better, not to sit inside its internal workings.

“AI agent” is arguably the most overused and least understood term right now. An agent is basically an AI function where the steps aren’t all logically defined the way software is (if a, then do b) — the AI uses its probabilistic reasoning to decide the steps and tools it needs to reach the right output:

1. the agent gets triggered — at a certain time, by an event (an inbound invoice), or by another AI agent

2. the agent loads its baseline context about the task (its prompt), and then determines the data & tools it needs to complete it

3. the agent produces an output

What’s key in all this is that a human should never talk to the agent.

Instead, the only human involvement comes in evaluating the results in step (3). Did the agent produce a report based on outdated sources? Then tweak its instructions to only use sources from the last six months. Did it recommend a discontinued product to a customer? Fix its data sources so it can only retrieve valid products in the first place.

By focusing on just the outputs instead of overseeing each individual step, you are better able to understand which changes will have the greatest impact on the function as a whole, and put your efforts there instead. What you get is low quality at the start (as you no longer correct every step), but higher productivity and quality with each function improvement — until, finally, you can trust the function works so well that you never need to review the outputs at all.

What’s hardest about shifting from AI assistants to AI functions is that it requires you to surrender control.

This is particularly painful if you’re an expert practitioner in that function. Just like training a new employee, extracting all the knowledge and nuances of a process out of your head and putting them into a document (or context window) for another to consume can be long and frustrating. We often don’t even realize what judgements we’re applying until the obvious telltale signs show up in the outputs. The temptation to revert to the assistant management paradigm is ever-present... and very strong.

The key — and the most important part of making your AI functional — is to get rid of the chat interface. If you can monitor it while it works, you will end up doing so, one way or another.

But, if not a chatbot, then what? What you need instead is a new way of interacting: one that lets the AI do its thing, lets you review its outputs without getting frustrated, and gives you confidence that it is — or isn’t — getting better.

I call that new way of interacting the Captain Strategy, and it requires you to rewire both your work patterns and how you interact with your agents.

More on that in my post next week.

Michael Carroll is the founder of Coolhand Labs, which takes the drudge work out of AI maintenance and makes your agents self-improving. His own AI’s performance review of him reads: “lots of room for growth, but potentially still useful in Terminator-type takeover scenario.”