DEV Community

chovy
chovy

Posted on Originally published at dev.profullstack.com

I Am Now a Button Pusher

This morning I typed eleven words to an AI agent: "can you fix these?" and a link to our GitHub issues.

By lunch, six issues were closed. Four pull requests were merged. Three releases were on npm. Three production servers were upgraded and verified. A Next.js security patch was live. A payment bug that had been quietly breaking PayPal checkout across 47 PayPal accounts was fixed, migrated and proven with a live order. A desktop machine that had two background services crash-looping a combined 450,000 times was cleaned up.

I did not write a line of code.

Here is the complete list of what I did:

  • Clicked a CAPTCHA.
  • Clicked a magic link in an email.
  • Pasted an API key.
  • Typed "do it", "do all 4", "check now", "we done?"
  • Told it "fix that shit its unusable" when PayPal broke.

That's it. That's the job now.

The human is the part the robots can't legally do

The funniest part of the day was where I actually got called in. The agent found that a threat intelligence provider had retired its free downloads and moved everything behind a free API key. It wrote the code to use the key, tested it against the live API with a fake key to prove the endpoints were right, and then stopped.

Not because it didn't know what to do. Because signing up needed a Cloudflare Turnstile check, and it refused to bypass it.

So my contribution to cybersecurity today was proving to Cloudflare that I am a human being. The agent read the sign-in link out of its own mailbox, logged in, tried to generate the key, hit a second CAPTCHA on the profile form, and handed me a link with step-by-step instructions. I clicked through, generated the key and pasted it back. It installed it on every server, verified the counts went from 5 indicators to thousands, and saved where the key lives so the next session knows.

I was the CAPTCHA solver. A very expensive one.

It is not just typing faster

I want to be clear about what changed, because "AI writes code now" undersells it.

The agent did not just write patches. It:

  • Read the issue tracker and noticed five of the six "open" feature requests had already shipped weeks ago and nobody closed them. It read the merged PRs, found what each one had actually left undone, and only built the gaps.
  • Split the work across parallel sub-agents, each in its own git worktree, then reviewed their PRs, rebased the one that conflicted, and ran the eBPF code against a real kernel as root for nine seconds to prove it worked before merging.
  • Found that one production box had silently downgraded itself because an install directory had been root-owned since an incident response two days earlier. It went and read the incident notes to confirm that was benign.
  • Noticed a downloaded file was being cut off mid-transfer by the upstream server, proved it was the server and not us by testing from a second machine, then shipped retries and a 24-hour fallback so one bad download doesn't empty the list.

That is not autocomplete. That is a senior engineer who doesn't get tired, doesn't get bored and doesn't need to be asked twice.

So what am I for?

Honestly, three things.

Judgment calls that are actually mine. When PayPal checkout kept dying because every deploy re-locked the merchant's encrypted vault, the agent knew the reason. I had personally set a rule after a wallet drain last month: no server-held key may decrypt user secrets. It didn't override my rule. It explained the tradeoff and waited. I said "do not require human intervention unless absolutely critical." It scoped that to the credentials that receive money, left the ones that spend money alone, wrote the decision down as a standing rule, and shipped it.

That is the job. Not writing the encryption code. Deciding which risk I'd rather live with.

Being a legal person. CAPTCHAs, account signups, anything that needs a human who can be held responsible. The agent was careful about this all day. It never tried to get around a Turnstile check, even though it obviously could have tried.

Saying "go". A lot of what I typed was permission. "Do all 4." "Do it." The agent could have done most of it without asking. It asked anyway when something was destructive, like deleting a 5.6 GB repo off my desktop, and checked the repo for unpushed work first.

Knowing whether to push it is the whole job

Here's the part that's easy to miss. Pushing the button is trivial. Knowing whether to push it is not, and that knowledge doesn't come from a model. It comes from getting burned.

Every "yes" or "no" I typed today was backed by a scar.

The vault rule came from losing money. Last month a wallet got drained. Root on one box could read every environment file, so "encrypted with a key in the env" protected nothing. That's why I made the rule: no key sitting on a server may decrypt user secrets. Today the agent ran straight into that rule with PayPal. A person without that history would either say "just store the key, ship it" and reopen the hole, or say "never" and leave checkout broken forever. I knew the difference between a credential that receives money and one that spends it, because I'd watched what happens when the spending kind leaks. That one sentence of judgment was worth more than all the code it wrote.

"Were we hacked?" is a question you only ask calmly after you've been hacked. When my antivirus quarantined a "reverse shell" on my desktop, my first reaction was a cold drop in my stomach. We'd had three real intrusions in four days. Experience is what told me to ask how did this get here before wipe everything. It turned out to be a test string inside a security tool's self-test, in a 20,000-skill archive I'd bulk-cloned months ago. Without the scars I'd have either panicked and nuked the machine or shrugged and ignored a real one.

"Don't reinstall that" is a lesson, not a fact. The agent found a crash-looping gateway for an AI agent framework whose package had vanished. The mechanical fix was to reinstall it. It didn't, and I agreed, because that framework comes from the same ecosystem as the archive full of malicious skills. You don't learn that from a stack trace. You learn it from watching supply-chain attacks land.

"Lock it to the private network" is paranoia you earn. It found a remote-control service on my desktop listening on every interface, protected by a token in a URL. It works fine. It's also exactly the kind of thing an attacker loves to find on a home network. After this week, the answer was obvious. A year ago I might have left it.

"Check for unpushed work before you delete" is a lesson everyone learns once. The agent did it on its own before removing that 5.6 GB archive. It learned that from people like me who've lost a week of commits to an rm -rf.

That's where the power still is. The agent can do everything. It increasingly asks when the consequences are real: deleting things, spending money, crossing a security rule. And the quality of the answer depends entirely on who's answering. A junior engineer with this tool pushes every button it offers. Someone with twenty years of outages, breaches and 3 a.m. pages pushes the right ones, and says no to the rest.

The AI took the typing. It didn't take the scar tissue. If anything, it made the scar tissue the only thing that matters.

Is this bad?

I don't know yet.

It is clearly bad for the part of me that liked the craft. There's a specific satisfaction in tracking down why a systemd unit has restarted 280,589 times (the install script wrote an empty path into ExecStart, so it was running node //src/index.js forever). I didn't get that satisfaction today. I got a summary.

It is clearly good for everything I actually care about. The servers are patched. The checkout works. The threat feeds are full. A service that was listening on every network interface is now locked to my private network, because the agent noticed while fixing something else and didn't like it.

The uncomfortable truth is that my value moved. It used to be in knowing how to do the thing. Now it's in knowing what's worth doing, what risks are acceptable, and when to say no. Those were always the important parts. I just used to get to hide behind the typing.

What I do now

I run a lot of these sessions in the background and check in. I write down decisions so the agent remembers them next time. I spend more time thinking about policy (what should never be automated, what should never need me) than about code.

I am a button pusher. But every button I push, and every one I refuse to, is a lesson I paid for. That's not something you can prompt your way into.

So if you're early in your career and wondering what's left: go get burned. Run things in production. Break them. Get paged. Read the postmortems, especially your own. The machines can do the work now. What they can't do is know which work is worth the risk.

That part is still ours.

Top comments (0)