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
Post a Comment