Travis Colbert

AI is here. It isn't going anywhere but raging deeper into our existence — disrupting everything in its path. It is an immensely powerful beast that is already transforming our lives.

But the beast is very much untamed, isn't it? Because of that, I've come to realize that we must develop a healthy and protective respect for the technology. A critical key is developing an internal alarm for when we are placing too much trust or agency in AI. Otherwise put: we need to better understand when we might be sacrificing some of our responsibility for the short-term benefits of quickly busting out work through the use of AI.

Here's an anecdote that illustrates this point for me:

A Simple Sort

Recently, I was working with a Ruby hash and wanted to sort my hash by key. There were 82 keys in the hash. I wanted to alphabetize them.

This is a perfect example of a simple task that I wouldn't have thought twice about offloading to my ever-eager AI assistant. So, I hit ctrl-i in VSCode and asked: sort this hash by key alphabetically ascending.

This should be easy, right?

After the sort, I started comparing keys from this hash to some other data and, after a few minutes and much confusion, I noticed that there were keys missing!

I had 80 keys after the sort. Somewhere, AI hallucinated the deletion of 2 keys in my hash.

I haven't dug into why those keys were missing because I believe that's missing the point. The point is: you cannot hand over the care of your data to an entity that cannot bear responsibility for it. I put my data directly on the back of the bull, slapped the 2,500-pound Angus on its hind parts, and expected it to carefully convey my data from one state to another. Instead, it raged off as if in a rodeo and shook random pieces off in the process.

It is up to you to retain agency over your work

This raises a crisp caution when using AI: instead of offloading the direct mutation of your data to AI, it is probably safer to ask AI to create a tool or process to mutate the same data. In the above case, it would have been better to ask my eager AI assistant how to sort the hash by key alphabetically. In that case, I'd get what Rubyists would have told me from the beginning:

{the_hash}.to_a.sort.to_h

That's a tool that I could have used to mutate my data. Using the tool, I would have still retained agency and responsibility over the data. After all, AI would not have gotten dinged for dropping the keys — I would have.

Like sitting your young child on the back of a bull — putting something valuable in the hands of an entity that is unable to bear responsibility for it is the height of irresponsibility.

Avoid the ambivalence vortex

Just as AI will not bear responsibility for what it does, it also does not care about what it does.

Conversely, since we bear responsibility for what we do, we must also, care about it.

The nuance here is that AI cannot reasonably be blamed for what it does. On top of that it wouldn't care even it was blamed!

AI can be programmed to appear to care, but it obviously can't. And sometimes it fails at faking it in spectacular ways.

Because AI is so powerful, apparently so capable, so eager to please and might seem to care it is increasingly easy to disconnect ourselves from the very processes we are supposed to be responsible for. In this intellectually disconnected state, we start ambivalently shoveling tasks into the black box that is AI.

Disconnected is no way to exist. Climb out of the ambivalence vortex by remaining invested in your work. Care enough about your work to ensure that you are capable of speaking for it.

In practical terms, this means we must understand it. So, as we continue to acclimate ourselves to using AI to create, we should try our best to fully understand what is being created.

When undertaking a new thing, ask yourself: "How would I tackle this thing?" Form a plan of attack and perhaps test it against AI's approach. In this way, we are invested, responsible, and also in a state to improve our own abilities.

In reality none of this is new. Before we merge that PR, it's on us to understand it. So, nothing's changed except that we're implementing a review process well before we get to the PR stage.

Actively find ways to improve your AI-weilding abilities

This post isn't meant to take on a negative tone. On the contrary, I am awestruck by how Claude, Gemini, ChatGPT and others have gotten me unstuck or refined my work. I want to use it more in areas where it is appropriate. But, I want to ride the bull, not be thrown off by it.

So, what are are some ways to do that? Here are a few ideas:

• Use AI to create your tests. Everybody hates writing tests, right? So, let AI do it. Of course, in every area where we reap benefits of using AI, we must accept that there is a new "vetting stage" that gets inserted.
• Use AI to build scaffolding for your code. AI can help you get started on a project by generating the basic structure.
• Try using AI to generate documentation. This is another hated chore. AI might help build a healthy documentation culture. This is a sure-fire way to at least understand the code that is being generated. A side effect is that you might find yourself "leveling up" your own skills.

Advice

So, my advice is this:

• AI will never take responsibility for what it creates — the responsibility falls on you and me. So, don't unleash AI directly on your data. Instead of asking AI to directly manipulate some data, tell AI to create the tool that will mutate the data.
• Retain investment in your creation — whether it be programming or some other creative process — by asking yourself first: "How would I tackle this thing?" "Can I explain this thing?" If we're having trouble with these questions, we are probably being pulled into the ambivalence vortex.
• Find places in your workflow where AI can help you gain big benefits without sacrificing your responsibility. For example: use AI to create tests, scaffolding, or documentation.

I think this is perfectly exemplified by this very recently released GitHub repo: https://github.com/cloudflare/workers-oauth-provider/. Check the last few paragraphs of the readme for how the authors 1) retained agency over their work, and 2) how they avoided the ambivalence vortex. This is how you ride the AI bull responsibly.