Born Against: The Friction Between Hobbyist Devs and LLMs

By Fogus | 2026.08.04

A recent GitHub discussion regarding the creation of chess engines sparked a realization for me: there is a growing, aggressive hostility toward Large Language Models (LLMs) within specific hobbyist programming circles.

While that specific thread didn't provide a definitive answer, it served as a catalyst for me to analyze why this sentiment is so prevalent. I've observed this same friction in various niche sectors, including:

• OSDev (Operating System Development)
• LangDev (Language Development)
• TxtDev (Text-based Development)
• EmuDev (Emulator Development)
• RLDev (Reverse Engineering/Low-level Dev)
• The demoscene
• Code golfers

The Philosophy of the Struggle

In these specific realms, there is a prevailing belief that the knowledge acquired is hard-won. Consequently, using an LLM is viewed as getting the answer missing the entire point of the exercise.

For these practitioners, the act of conquering a grueling technical challenge is the actual "product." Whether the final code actually executes is often a secondary, "nice-to-have" bonus.

Comparing Value Systems

Feature	Traditional Hobbyist View	LLM-Driven Approach
Primary Goal	Mastery of the domain	A working prototype
Value Source	The struggle/learning process	The final output
Metric of Success	Understanding the why	Achieving the what
Pace	Painstakingly slow	Instantaneous

The Social Dynamics of Niche Dev

These communities are not without flaw; they have a history of intense gatekeeping and glacial progress. This environment creates a temptation for newcomers to bypass the grind and gain instant status—essentially bursting into the community like the Kool-Aid Man.

However, in these circles, prestige is not bought with working code, but earned through:

• Years of consistent forum activity.
• The sharing of elegant, minimalist code.
• Demonstrating an insatiable, genuine curiosity.
• Contributing deep, specialized domain expertise.

The Path to Respect

The Tool vs. The Surrogate

I believe the utility of an LLM depends entirely on the user's starting point. It should be a force multiplier, not a replacement for the human mind.

If we express this as a conceptual formula: $\text{Result} = \text{Domain Expertise} \times \text{LLM Leverage}$

If $\text{Domain Expertise} = 0$, the result is effectively zero in terms of actual craftsmanship.

def learning_process(student):
    while not student.understands_why():
        student.struggle()
        student.fail()
        student.research()
    return "Craftsman"

# LLM usage often skips the loop:
# return "Working Code" (but not a Craftsman)

Using an AI to generate a finished project doesn't transform us into artisans; it simply strips away the craft itself.

---

Further Reading:

• LLMe
• Mind the van Emden Gap

Final Note: It is important to remember that even high-level expertise provides no inherent shield against being misled by LLM hallucinations.