Negative Influence Is Still Influence (Or: How the Em-Dash Became a War Crime)

Let me tell you about a genuinely stupid thing I did for a good chunk of my teenage years: I avoided books, films, and shows because they were popular.

Not because I’d tried them and disliked them. I hadn’t tried them. That was the point. Popular meant herd, herd meant being like everyone else, and being like everyone else was, in your teens, roughly equivalent to death. So I built an entire personality around being the opposite of whatever was trending. Different music, different taste, different opinions, all loudly held and none of them actually examined.

Here’s the part I didn’t notice at the time, mostly because teenagers are not famous for noticing nuance: to reliably avoid every popular thing, I had to keep track of every popular thing. Not that this took any effort — the internet back then was about as widespread as a dinner invitation from the President, so I wasn’t refreshing some chart. I just had to listen. The other kids at school, the ones out in the yard, they were a perfectly good real-time feed all on their own. How else do you know what to be the opposite of?

So the trends were absolutely steering my choices. Just… negatively. The needle on my “influence” gauge was pinned to the wall — it merely happened to point the other way.

The bill came due years later, when it finally dawned on me how dumb this was and I started going back to catch up. Some of it turned out to be genuine treasure I’d denied myself out of sheer pose. And some of it — this is the fun part — confirmed I’d missed absolutely nothing. Which, if anything, made the whole exercise more embarrassing: I’d spent all that energy gatekeeping myself, and half the gate was protecting an empty field.

That’s the whole post, really. But let’s pour another one, because it gets worse — and more expensive — when grown adults do it with production systems.

The Pendulum Doesn’t Stop in the Middle

Quick physics reminder for those of us who slept through it: if you pull a pendulum all the way to one side and let go, it does not gently return to center and call it a day. It swings past center, all the way to the other side, and then spends a while wobbling before it settles.

People do this. Industries do this. Entire fields do this. We overcorrect, congratulate ourselves for fixing the old mistake, and quietly commit the mirror-image mistake instead — which we won’t recognize for another decade because it feels like progress.

I’m not going to touch politics here, so relax. Plenty of pendulums swing through that particular room and I have exactly zero interest in getting hit by one. I’ll just gesture vaguely at “every reform ever rejected purely because the other team proposed it” and let you fill in your own example. You’ve got one. Everybody’s got one.

And that’s the thing about this mechanism: it isn’t confined to public discourse or the contrarian purchasing decisions of fifteen-year-olds. It’s everywhere. Once you learn to spot it — the reflexive swing to the opposite wall, dressed up as an independent opinion — you start seeing it in code reviews, in hiring debates, in which framework your team refuses to touch, in your own gut reactions before you’ve finished reading the sentence. And I have bad news: you cannot unsee it. Sorry in advance for ruining several of your future arguments.

Let’s talk about something safer. Let’s talk about architecture, where the tribalism is just as fierce but the stakes are only your on-call sleep schedule.

Exhibit A: The Microservices Bender

In the ’90s and 2000s, applications were monoliths. And you know what? For shipping software on a physical disc that nobody would meaningfully update for years, that was fine. Correct, even.

Then the internet showed up, SaaS happened, and the monolith started to creak. Reasonable response: break things apart where it helps. What we actually did: pull the pendulum clean off its hinge.

Everything to the cloud. Everything into a bazillion tiny services. I personally witnessed, in the early 2010s, an application where a single request to the server kicked off a conga line of a dozen-plus microservices. Each with its own database. And because this was also peak NoSQL, each with its own MongoDB instance. Calling that application “slow” is like calling a tornado “a bit of a breeze.”

The good news about pendulums is that, left alone, they lose energy and settle down. So here we are, in the boring, sensible middle: sometimes cloud, sometimes on-prem, sometimes — brace yourself — a monolith, because it turns out the right answer depends on the actual problem. Amazon Prime Video famously moved a serverless, microservices setup back to a monolith once they realized their pain wasn’t application complexity; it was scale relative to user volume. The heresy worked. Costs dropped. Nobody was excommunicated.

The bad news about pendulums is that phrase — left alone. Because in plenty of arenas they are not left alone. There are people whose entire job, or hobby, or identity, is standing next to the pendulum and shoving it, hard, in one direction, every time it dares to slow down. You can watch this happen in real time in the rising temperature of public discourse, where — as previously established — I will be taking exactly no position, thank you. A pendulum that keeps getting pushed never settles. It just swings harder, and the people getting hit keep changing. In technology the shovers wear a friendlier costume: they’re revolutionary startups whose founders announce, with total sincerity, that they’ve reinvented the wheel in the name of progress. See Juicero — go look it up if you’ve somehow forgotten, it’s worth the ten minutes — and understand it’s just one entry in a very long, very well-funded catalogue.

The pendulum wound down. As they do. Until someone gives it a fresh shove.

Exhibit B: The Shove Is Called AI

2024 and 2025 were the “the machine writes it now” years, in every medium at once — prose, email, code, the lot. 2026 brought the hangover. Turns out the confident autocomplete is, occasionally, confidently wrong, and someone still has to know why. Fair. Healthy, even. The pendulum was always going to swing back toward “human judgment matters.”

Except it didn’t stop at “human judgment matters.” It kept going, the way pendulums do, straight into the other wall — and this is the part that actually bugs me. Start with language, because that’s where it’s pettiest.

People are now so terrified of being accused of using AI that they’re amputating perfectly good rhetorical techniques from their own writing. Observe:

• The em-dash. Fifteen, twenty years ago this was just punctuation. Unfashionable punctuation, sure — using it well required a feel for language that was frankly above average — but writers reached for it happily. Now people avoid it like it’ll show up on a background check.
• The rule of three. Aristotle was doing this. Aristotle. It’s in the foundational texts of rhetoric. Today it’s “proof” you outsourced your paragraph to a language model.
• “It’s not X, it’s Y.” A decade ago this was antithesis with negation, a standard move taught in the art of argument. Today it’s EVIL. Capital letters. Burn it.

Yes, that was exactly three examples. No, that was not an accident. I gave you a clean rule of three, on purpose, in the paragraph defending the rule of three, and if that makes you suspect a language model wrote this — congratulations, you’ve just demonstrated the entire thesis in real time. Have a seat.

And look — yes. The language models did overuse all of this. I’m not going to pretend em-dashes didn’t get carpet-bombed across the internet for two years straight. But stripping your own language of these techniques to prove you’re not a robot is not resistance. It’s the exact same thing I was doing when I refused to read a book because other people liked it.

You’re not rejecting AI’s influence. You’re letting AI decide how you write. Negatively. The needle’s still pinned to the wall.

(And yes — the em-dashes. Full confession: the models changed how I put thoughts on a page. I’ve always been a digressive thinker; now I’ve got the tooling to indulge it, so no, the influence doesn’t only run one way — I gave that whole loop its own case in Chapter 40 of Fuckup Almanac Vol. 2. What I won’t do is let a diffusion model repossess punctuation I was using long before it learned to.)

Exhibit C: The Code Purity Spiral

Now the software version, where the same swing has commit history.

2024 and 2025 were also the “everyone’s a programmer now” years. Ship the chatbot, replace the greybeards, who needs twenty years of hard-won context when you’ve got a very confident autocomplete. You remember. You were there. Maybe you sold some of it. We went from “we write all the code” to “the AI writes all the code” in roughly eighteen months. And the backlash is already here, arriving right on schedule and swinging just as hard.

OpenJDK — the reference implementation of Java, not some hobby repo — approved an interim policy this year banning AI-generated contributions outright. Not just code: source, docs, pull requests, emails, wiki pages, bug reports. And they mean it: edit ten of a hundred AI-generated lines and it’s still banned, because it’s still, in part, AI-generated.

Now, to be fair to them, their main reason is legal, not vibes: their contributor agreement requires you to own the IP you’re handing over, and whether anyone owns the output of a generative model is, as they put it, currently being fought over in court. That’s a genuinely reasonable thing to be nervous about. Fine.

But here’s my favorite part, and it’s the part that proves the pendulum thesis better than I ever could. OpenJDK admits, in writing, that reliably telling human-written content from AI-written content is basically impossible — and then, in the same breath, tells reviewers to watch for tell-tale signs like chatty commit messages, unnecessary comments, and emoji. Read that again. It’s the em-dash witch-hunt, wearing an enterprise lanyard.

And the cherry on top: Oracle also runs GraalVM, which explicitly welcomes AI contributions. Same company. Same contributor agreement. Opposite rules. One project treats the IP uncertainty as grounds for a total ban; the other treats contributor accountability as good enough. If you wanted a diagram of a pendulum caught mid-swing, you could just screenshot Oracle’s org chart.

Meanwhile there are now curated directories of “slop-free,” AI-untouched software, so you can shop for purity like it’s organic produce. I’m not knocking anyone’s right to do this — it’s their repo, their rules. I’m just noting, with love, that “absolutely no AI, ever, under any circumstances” is not the calm center of the pendulum. It’s the other wall.

So, Last Call

I don’t know what this industry looks like in a year or two. Maybe the models get good enough that the whole argument feels quaint. Maybe we’re all writing COBOL in a bunker. I genuinely can’t call it.

But I’m confident about one thing: both extremes are equally dumb. “AI writes everything” gave us confident nonsense shipped to prod. “AI touches nothing” is giving us people who won’t use a dash they’ve used their whole lives. One extreme outsources your judgment. The other outsources your judgment to spite. Same missing judgment either way.

And we’ll probably get there the way we always do: by wobbling for a few years and then quietly rediscovering the two most sensible, most resented words in the entire industry: it depends. Nobody wants that on a conference slide. It doesn’t sell a startup. But it’s usually the calm center the pendulum was heading for the whole time, once everyone finished shoving.

So next time you evaluate an idea, an architecture, a tool, a technique — before the opinion leaves your mouth — ask yourself one honest question:

Do I actually dislike this? Or do I just dislike who’s associated with it right now?

Because negative influence is still influence. And if the trend is deciding your position — even by pushing you the other way — then you never really had a position. You had a reflex.

The pendulum doesn’t care which wall it hits. Don’t be the wall.

You’ll find more of these trips into the land of absurd in Fuckup Almanac Vol. 2, where I use fully documented, real-world cases to lay out exactly what goes wrong when we put blind faith in algorithms and AI — the RLHF story behind that em-dash confession among them.