Skip to main content

The Last Button I Almost Handed Over: Where Automation Crosses Into the Irreversible

Once reading numbers became second nature, my eyes kept drifting to what sat next to it.

After you read something and know it, there was always a human task waiting right behind. If I learned a customer would decline next month, someone had to be told. What I told them had to be written down somewhere. After writing it down, the next follow-up had to be scheduled. I'd handed the reading to the machine, but everything that came after reading was still done by my own hands: opening a mail window, filling in a recipient, writing the sentences, pressing send, logging it, dropping the next date into a calendar.

Which is when I noticed I'd only ever handed off one kind of work. Fetching, counting, displaying. Handling information. Beyond that lay a whole untouched continent: contacting people, composing text, recording what had been done. Tasks that took real effort, yet I'd never once thought to automate. That continent came into view all at once. That's just more of the same repetitive work I do by hand, isn't it? Couldn't I hand that over too?

The Line I Should Have Drawn

This is where I should have stopped, something I only understood much later. Everything I'd handed off so far shared one trait: it could be undone. Scrape the wrong number, scrape it again. Misread a trend, read it again. No one got hurt. Run it a hundred times and nothing happens in the outside world; numbers just blink on and off inside a screen. So I was fearless. Being unafraid of mistakes, I kept throwing; throwing kept it fun.

But the tasks I now wanted to hand over weren't like that. A sent email can't be recalled; a badly worded note has already been read by someone. Work that used to end inside the screen was about to step outside it and reach a person. I didn't feel the difference at the time. I saw only "this too is repetitive handwork," not "this one can't be undone if it's wrong." Looking back, it's strange. Isn't that a difference anyone knows, that erased text and a mailed letter are not the same thing? And yet, inside the frame of "automation," the two got lumped into one bucket called "manual work." The single act of handing something to a machine erased a line a person would normally draw without thinking.

Handing Over the Writing Itself

The first thing I reached for, oddly, was composing text. I kept needing to write short notes from the numbers I'd read, this customer looks like this, that one like that. The same template with different figures slotted in. So why not have the machine do this too? Feed in the numbers, and have the sentences explaining them appear on their own.

I still remember receiving that first paragraph. I dropped in a few numbers, ran it, and clean Korean prose appeared, smooth, not far from my own usual voice. A paragraph I'd have spent ten minutes polishing by hand was composed whole in the blink of an eye. I read it out loud. Nothing awkward. If anything, tidier than what I'd write. So it does the writing too, not just the fetching. Something in my chest went faintly cold at that, but the novelty was much larger, and I let the chill pass.

It spread from there. If short explanatory notes worked, why not longer pieces? Notices, summaries, even content closer to something you'd publish. Writing had sat, in my head, in the slot reserved for "things only a person can do," and that slot quietly crumbled.

The problem is that writing is not like numbers. A number is either right or wrong. But prose can be not wrong and still be the kind of thing you shouldn't say. The figure is correct but the tone is too strong; the fact is accurate but a reader could misunderstand. Once, skimming a generated note, I caught a sentence pulled taut like a drawn bowstring. It had written "this is concerning" about a number, when the situation didn't warrant that much worry. The machine had merely transcribed the figure, no exaggeration, no understatement, but that flat sentence could land differently on the person receiving it. Not a wrong note, a note pitched at the wrong level.

The machine's writing was always plausible. That's exactly what made it dangerous. Because it was plausible, I wanted to just send it. But "plausible" and "safe to send" are different questions, and the only thing that bridges them is a person reading it once. At first I kept trying to skip that one read. The smoother the draft, the less I wanted to check it. Mistaking smoothness for correctness, I'd let a tidy paragraph slide past my eyes and go, good enough. That "good enough" had, in fact, confirmed nothing at all.

When the Hand Stopped on Its Own

Handing over the contacting was where the line was fully crossed. I began letting the machine send mail: fill the recipient, drop in the drafted text, send.

At first I was careful. I had it stop just before sending, so I could eyeball the recipient and the body, and press only the final button myself. There was a small hesitation before that press. I didn't realize that hesitation was the safety mechanism. I took it for a tedious confirmation step.

It didn't take long for even that single hesitation to feel like a nuisance. The address was always right, the body always fine. Ten presses, ten times fine, and on the eleventh your hand presses before your eyes follow. So I started to wonder why a person had to press this button at all. Since I always press it anyway, couldn't the machine do this too? I wanted to hand over even that last button. Even as I decided to, I didn't think of it as crossing a line. Just trimming one more tedious motion.

I still remember the moment the thought "hand over the last button too" arrived. I was sitting in front of a screen paused right before send. The recipient field held a name; the body held text the machine had drafted, sitting there obediently. All I had to do was skim it once and press send. And that "skim once" had somehow become annoying. My fingers got to the very edge of typing "I could let the AI handle this part too."

Then my hand stopped. Not my head, my hand stopped first, because I looked again at the name in the recipient field. That was not a number. It was a person's name. A wrong number could be re-pulled, but once a wrong note flew to this name, that person had already read it. No window to undo. Text that is mine only until I press, and becomes irreversibly someone else's the instant I do. A chill went down my back. That day I didn't type "hand over the last button." I skimmed it by hand, and pressed send by hand.

But the hesitation didn't last. The next day, and the day after, the sent notes were fine, and as the fine days stacked up, yesterday's chill faded. In the end, for some tasks, I quietly began skipping even that last skim. Once was fine to skip, and being fine repeated, it settled in my head as "a task I don't need to look at." That line I'd flinched at, I crossed again, smoothly.

Writing the code to send mail was never the hard part. Deciding the recipient, subject, and body, the sending is the machine's job. The one thing I failed to decide was this: the to and body handed to that function, should a person see them once before they go, or should the machine draft them and send straight through? Writing the code was the AI's job; deciding what a person must keep hold of to the very end was mine. And that judgment, I blurred away, drunk on "this works too."

Fetching, if wrong, you just fetch again. Sending, once it goes, is done. A badly drafted note, to the wrong person, gone beyond recall. I knew the difference in my head. Even as I decided to hand it over, a thought clearly grazed me, "but this can't be undone", short, like a passing breeze. And my hand moved as if it hadn't heard. Instead of catching that thought and dragging it into "then stop," I let it pass. I was in a hurry to get it running, and the thrill of making it work was bigger than that small unease. I handed off the irreversible with the same light heart I'd handed off the reversible. Not because there was no unease, but because there was, and I pretended not to see it. That's the part that stings more.

The boundary I should have drawn was simple: tasks a person must glance at one last time, versus tasks a machine can carry all the way. But back then I had no such boundary. "If it works, hand it all over" was the only rule I owned, putting the undoable and the harmless on the same scale and shoving both into one slot called "repetitive handwork." The reckoning, as it happens, was waiting one chapter further, the day I opened the code to clean up a password I'd typed straight into it.

This essay is adapted from one of my Korean e-books on automating my own enterprise work as a non-developer. Details are anonymized: no company, system, or tool names, only the shape of what happened.

Related reading: When One Number Became a Judgment Call: Reading Trends, and the Day Two Lookups Disagreed · I Was Keeping Passwords in My Code: A Non-Developer's First Taste of Technical Debt

Comments

Popular posts from this blog

AWS vs Azure vs GCP in 2026: Which Cloud Platform Should You Choose?

The cloud platform decision is one of the most consequential technology choices an organization makes, and in 2026 it's also one of the most misunderstood. Most of the debate I see in enterprise architecture forums reduces to "we're an AWS shop" or "we go Azure because of Microsoft" — neither of which is a strategy. A platform choice made primarily on inertia or existing vendor relationships is a choice that will cost you for years. I've spent significant time in all three major cloud environments — AWS for scale workloads and data engineering, Azure for enterprise SAP and Microsoft-integrated architectures, and GCP for AI-intensive and analytics-heavy use cases. My goal in this guide is to give you a genuine, nuanced comparison that goes beyond feature lists and into the practical realities of choosing and running a cloud platform in 2026. I'll cover market position, each platform's honest strengths and weaknesses, how to match workloads t...

EU AI Act Compliance in 2026: What Every Enterprise Needs to Do Now

EU AI Act Compliance in 2026: What Every Enterprise Needs to Do Now The EU AI Act entered into force on August 1, 2024. The first provisions took effect six months later, and the full implementation timeline runs through 2027. If you're building, deploying, or using AI systems in or for the European Union, this law applies to you — and the window for being caught unprepared is closing fast. I've spent the past year working with enterprise clients on AI governance programs, and one pattern shows up again and again: organizations badly underestimate how much operational work compliance actually takes. It's not a checkbox exercise. It's a rethink of how you develop, document, deploy, and monitor AI systems. This guide is what I wish someone had handed me when I started — the substance of the law, the practical requirements, the deadlines that matter, and the mistakes I keep watching enterprises make. Photo by Petrit Nikolli on Pexels Photo by Karolina Gra...

I Was Keeping Passwords in My Code: A Non-Developer's First Taste of Technical Debt

While I was hastily building ten automations, I was writing passwords straight into the code. My excuse was that it was fastest. To log into a system you need an ID and a password, and if you don't put them somewhere in the code, the automation can't log in. A human just types them when the login screen appears; an automation has no hands to type. So I took the simplest road: I wrote them on the top line of the code. ID is this, password is that. It worked. And because it worked, I waved it off. What matters is that it runs — who cares where I wrote it down? It's code only I use, sitting only on my laptop. Nobody's going to open my laptop and read this file. That's how I talked myself out of it. Actually, "talked myself out of it" is too generous. I never even registered it as a problem. The question "is this okay?" never once surfaced in my head. The convenience that quietly becomes a liability The trouble with a shortcut like this is th...