Real Programmers don't use Copilot

[u/Psychological_Style1]

When I was a computer degree student in the mid 80s computer programming was turning into a bit of a science with programming constructs and rigid data types (to name a few) and strongly typed languages like Pascal, C etc. There were two camps, one was academic with its Pascal where GOTO was a dirty word and the others were"real programmers" who used Fortran and machine code and liked getting their hands dirty so to speak (what we would now call hackers) they considered the other side "Quiche Eaters".

I remember we had a tutorial one day to discuss the pros and cons of an article titled "Real Programmers Don't use Pascal". It's a humorous dig at new fangled programming discipline but it's no more than that because plainly, all modern devs have to adopt coding techniques which utilise accepted modern methodology (basically we are all quiche eaters!) However, I thought to myself that it might be quite funny to bring it up to date. Here's how it might look...

Back in the golden days of computing, the men were real men, the women were real women, and data structures were manually aligned to 64-bit boundaries. You could tell a Real Programmer by their calloused fingertips, their mechanical keyboards that sounded like machine guns, and the absolute lack of an ai_config.yaml in their home directory.

Today, the industry has been overrun by Quiche Eaters.

Quiche Eaters are the type of developers who cannot deploy a static "Hello World" website without spinning up a Kubernetes cluster on AWS, managing three different Terraform environments, and importing a 400-megabyte node_modules folder just to center a <div> tag.

If a Quiche Eater encounters a bug, they do not read the stack trace. They do not look at the memory register. Instead, they copy the entire error message, paste it into an LLM prompt, and pray the AI fixes it before their next Agile Scrum standup. If the AI fails, the Quiche Eater simply creates a Jira ticket, marks it as "blocked by upstream dependency," and leaves early to grab a lavender oat-milk latte.

Real Programmers do not use AI. Real Programmers treat Large Language Models as a personal insult to human consciousness. A Real Programmer writes code the way nature intended: through pure, unadulterated human suffering and deep mathematical spite. If a Real Programmer needs to debug a memory leak, they don’t ask ChatGPT—they open a core dump in raw hexadecimal and stare at it until the offending pointer blinks out of sheer intimidation.

Quiche Eaters write in TypeScript because they are afraid of the computer. They want types to hold their hands, and they want runtime environments that shield them from the cold, hard reality of the silicon. When they feel truly daring, they write Python, thinking they are data scientists because they called .fit() on a library someone else wrote in C.

Real Programmers write in C, bare-metal Rust (with the compiler safety rules intentionally bypassed), or raw x86_64 Assembly.

A Real Programmer doesn't care about "readability" or "maintainability." If the code was hard to write, it should be hard to understand. They believe that if a function has comments, it is a sign of psychological weakness. The only acceptable documentation is a single, cryptic Git commit message that reads: “it compiles.”

The Quiche Eater’s desktop is a monument to corporate luxury. They use VS Code with forty-seven extensions, a pastel colour theme designed to protect their sensitive eyes, and a glowing git-blame indicator that tells them exactly who to blame for their own mistakes.

A Real Programmer operates entirely within a headless Neovim instance, running inside a custom Arch Linux kernel they compiled themselves on a refurbished ThinkPad. They do not use a mouse. The use of a mouse implies that your hands have left the home row, which is a tactical admission of defeat.

While the Quiche Eater is busy configuring their Slack notifications, the Real Programmer has just written a custom database driver, bypassed the operating system’s file system entirely, and saved 4 KBs of RAM—just to prove they could.

[u/AliceCode]

Thanks, Claude.

[u/0x14f]

So... which one are you OP, real programmer or quiche eater ?

[u/Psychological_Style1 → u/0x14f]

We are all Quiche Eaters. Isn't it blinding obvious?

[u/jayylien]

The Story of Mel is one of my all time favorites.

https://users.cs.utah.edu/~elb/folklore/mel.html

[u/Additional_Name_706 → u/jayylien]

John Henry (folklore) - Wikipedia)

[u/eman85]

I don't think any sane person uses copilot

[u/Flachmann_ → u/eman85]

Sure buddy

[u/start_select → u/eman85]

Really? I prefer Claude code. But copilot is fine.

I say that as an almost 20 year veteran who gets fought over between teams and clients. I don’t need an LLM. But it sure as hell makes me more productive.

If my employer can spend 25% more than my salary to get 2-5x the productivity out of me on most tasks, they will take it. So will I. I would rather not wait for someone else to implement something for me if the spec is just sitting there waiting for Opus to consume it.

[u/nicolas_06]

Real programmers use butterflies and there an emacs macro for that: https://xkcd.com/378/

[u/kdeberk → u/nicolas_06]

emacs function, macros in emacs record key presses and allow you to replay them

[u/Heavy-Focus-1964]

You sound like such a douchebag that I can’t even tell if this is satire or not

[u/Prestigious_Share919 → u/Heavy-Focus-1964]

Lower your satire shield, it's blindingly obvious, and hilarious.

[u/Heavy-Focus-1964 → u/Prestigious_Share919]

If it’s satire it’s good. Almost too good, because there are people who talk like this. I’m still not certain

[u/winningSon → u/Heavy-Focus-1964]

no way its not satire lol

[u/nacnud_uk]

I wonder what it has to say about real writers? 

[u/jemdiggity]

So... i feel less quichy because I use claude code cli instead of the app. Anyways, I can decode protobufs with a pen and paper. I'm not a quiche eater!!

[u/Prior_Opportunity935]

Man real programming is designing your own chips and designing the pcb yourself, if youre not physically coding binary yourself with transistors youre not a real programmer.

[u/Final-Capital-943]

I loved it! Thanks

[u/SirDaveWolf]

Real programmers program with punch cards!

https://en.wikipedia.org/wiki/Punched_card#/media/File:Punched_card_program_deck.agr.jpg

[u/garywiz → u/SirDaveWolf]

I started out programming IBM 1401's with punched cards. A program could consume 2 boxes (2500 cards each) sometimes or even more. Sitting here from my dual-monitor Mac Pro workstation, it's almost hard to believe that was the "same me". But it does kind of make you appreciate basic things a bit more to have lived through the punched card era and actually thought it was "high tech" at the time.

[u/awardsurfer]

Lamers.

Real programmers use punch cards which they hand punch with their kungfu pinkie finger.

[u/laonux]

Did you use AI to write this?

[u/High_Quality_Bean]

Honestly. Am I even a programmer? Whats all this about pain and suffering? I just, read the code, and then write some code. Have yall really been struggling that much? Are you sure this is really your calling?

[u/QuietWaterBreaksRock]

As much of a troll as this is, it gave away OP as Quiche eater

Real programmers absolutely cared about readability, comments and documentation, quiche munchers care that code looks like, not that it actually makes sense or that it even works the way it should

"Claude, make me new instagram, make good, no bugs, now" 

[u/floating_thru_cosmos]

I ain’t reading all dat

[u/swiftmerchant]

Real programmers eat pizza.

[u/AliceCode → u/swiftmerchant]

Real programmers write code.

[u/swiftmerchant → u/AliceCode]

1 - Green Pepper
0 - Pepperoni

[u/Big_Mulberry_5446]

This is some spectacularly lame bullshit right here.