Developer with 320K Subscribers: I'm Sick of the AI Hype!

A veteran software developer and YouTuber with 320,000 subscribers (ArjanCodes channel) recently published a video that sparked widespread discussion, stating bluntly that he's "sick of the AI hype." He's not against AI — rather, he's offering a profound critique of the pervasive hype in the industry and the fundamental misunderstanding of what software development actually is. These perspectives deserve serious consideration from every developer.

Shipping Fast ≠ The Entirety of Software Development

Social media is flooded with posts like these: someone builds an entire AI Agent team — engineers, testers, project managers, the works — then ships a complete application in an hour and delivers new features in ten minutes. As if software development were a race where whoever ships the fastest and the most wins.

But is that really the case?

This creator points out that for startups, rapidly developing an MVP and validating ideas is indeed crucial. The MVP (Minimum Viable Product) concept originates from Lean Startup methodology, systematically articulated by Eric Ries in The Lean Startup. Its core logic is to validate business hypotheses at minimal cost and quickly obtain market feedback. This methodology is extremely effective in the startup context, but its premise is that the cost of failure is manageable and there's ample room for iteration. However, this represents only a small fraction of software development. Most software runs inside large enterprises, supporting various critical business operations that cannot be changed arbitrarily.

Large enterprise software systems carry fundamentally different constraints — compliance requirements (such as Basel Accords in finance, HIPAA regulations in healthcare), legacy system integration, data governance responsibilities, and SLA (Service Level Agreement) commitments. These constraints mean that "shipping fast" is not merely an engineering problem but a legal and business risk issue.

If you work at a bank or insurance company, "shipping fast" isn't a virtue — it's recklessness. It could expose confidential information, leak customer data, accidentally delete critical information, or corrupt key backend systems — all of which could result in millions in losses and a pile of lawsuits. Large companies don't care about shipping speed; they care about minimizing risk.

This is the first problem: you cannot blindly apply methodologies that work for indie developers, small teams, or AI startups to mature large enterprises. Their needs are fundamentally different.

Writing Code Is Just the Tip of the Software Development Iceberg

The second problem with current AI hype is that it assumes "software development = writing code."

Of course, we do write code. But frankly, it's only a small part of our actual work. According to research from Carnegie Mellon University's Software Engineering Institute, in large software projects, coding typically accounts for only 15%~20% of total effort, with the remaining time allocated to requirements analysis, system design, testing and verification, documentation, and project coordination. This closely mirrors the "iceberg model" in construction — the visible building work is just the surface layer of the entire project, while hidden work like foundation surveying, structural design, and material selection determines the building's quality and lifespan.

What a software developer does daily is far more complex than writing code:

• Design & Architecture: Thinking about the overall structure of the system
• Requirements Communication: Repeatedly discussing with stakeholders to figure out what actually needs to be built
• Writing Tests: Ensuring system reliability
• Creative Problem-Solving: Finding elegant solutions to complex problems
• Security Design: Making systems secure by default
• User Experience Thinking: How to make systems simpler and more usable
• Sustainability: Ensuring today's work doesn't need to be redone tomorrow

What AI tools can currently accelerate significantly is precisely that 15%~20% coding portion, while support for architecture design, requirements communication, and other hidden work remains quite limited.

The creator states plainly: "I consider writing code itself as an afterthought. If you think things through beforehand, writing code isn't the hardest part."

He uses a brilliant analogy: it's like saying you're a carpenter because you have an electric screwdriver. Sure, using a machine to drive screws into wood is convenient, but can you build a roof? Can you construct a wall? Driving screws is the easy part.

Responsibility Cannot Be Delegated to AI

Some might say: "This is just AI's current level; in a few years it'll be able to do architecture design and systems thinking too."

The creator offers a deeper rebuttal: if you don't have business experience, you might think running a company is just "delegating tasks." If that were the case, then AI could indeed replace everyone. But that's not how it works.

Running a business isn't about delegating tasks — it's about delegating responsibilities.

This insight touches on a deep legal and organizational management issue. Under current legal frameworks, AI systems do not possess Legal Personhood and cannot be held accountable as responsible parties. Whether it's the EU AI Act or relevant U.S. regulatory frameworks, all explicitly require humans to bear ultimate responsibility for AI system outputs. This means that even if AI generates flawed code that causes a system failure, the legally accountable party remains the developer who used the tool or their organization.

As a software developer, you're not just executing tasks — you're responsible for the outcomes. If you use AI to ship a feature that seriously damages your company's interests, AI won't be held responsible — you will. Your boss will hold you accountable, and you'll be fired. This won't change.

Someone has to bear responsibility, decide what to do, and verify it was done correctly. The "non-delegability of responsibility" is the most fundamental structural difference between AI tools and human employees, and it's why the "AI replaces developers" narrative has a fundamental flaw at the enterprise governance level.

Fundamentals Are a Developer's Core Competitive Advantage

So what skills does it actually take to be a successful software developer?

The creator's answer is concise: You need to master the fundamentals.

Only by mastering the fundamentals can you truly take responsibility for things. Just as building a house requires understanding basic principles of carpentry, building software requires understanding basic principles of software design and development. Cohesion, Coupling, Abstraction — these foundational design principles, and how to apply them in real projects, are what truly matters.

These three concepts represent decades of accumulated design wisdom in software engineering. Cohesion describes how closely related the elements within a module are — high cohesion means a module does one thing and does it well. Coupling describes the degree of dependency between modules — low coupling means modifying one module won't trigger a chain reaction. These two concepts were introduced by Larry Constantine in the 1960s and remain the gold standard for evaluating code quality today. Abstraction is the fundamental means of managing complexity — by hiding implementation details and exposing only necessary interfaces, it allows developers to think about problems at different levels. These principles don't depend on any specific programming language or framework; they are foundational cognitive abilities that transcend technological generations. AI can generate code that follows these principles, but judging whether the generated results truly conform to them still requires developers to have a solid theoretical foundation.

This is also why he doesn't discuss AI Agents much on his channel — because that's primarily related to "writing code," and writing code isn't what he considers the most valuable part. He explicitly states he won't turn his channel into an AI hype channel about "GPT-5 is going to crush Gemini" and will continue focusing on teaching the fundamentals that make you a great developer.

A Rational View of AI: Good Tools Don't Make Good Developers

It's worth emphasizing that this creator is not against AI. He himself uses AI tools extensively in his daily work. His core message can be summarized in one sentence:

"Use AI to boost your productivity, let it help you write code. But don't forget — you're the one in charge. You need to master the fundamentals; that's what truly matters."

This perspective is especially precious right now. When the entire industry is feverishly chasing AI Agents, Vibe Coding, one-click app generation, and similar concepts — Vibe Coding being a programming paradigm proposed around 2024 by OpenAI co-founder Andrej Karpathy, where developers describe their intent in natural language, rely entirely on AI to generate code, and don't even read or understand the generated code — we need someone to stand up and remind us: this approach may be efficient for personal projects, but the generated code may contain security vulnerabilities, performance bottlenecks, or hard-to-maintain technical debt that developers lacking fundamentals often can't detect.

Technical tools will keep evolving, but a deep understanding of software design, holistic thinking about system architecture, and accurate grasp of business requirements — these "fundamentals" are what developers truly depend on for their careers. When Vibe Coding drives the barrier to "writing code" toward zero, what becomes truly scarce is the ability to understand code, evaluate code, and take responsibility for its consequences.

Screwdrivers keep getting better, but the world will always need real carpenters.

Key Takeaways

• Shipping fast doesn't equal good software development; large enterprises prioritize risk minimization over speed
• Writing code is only a small part of software development (~15%~20%); architecture design, requirements communication, and creative problem-solving are the core
• Enterprises delegate responsibilities, not just tasks; AI lacks Legal Personhood under current legal frameworks and cannot replace humans in the critical role of bearing responsibility
• Mastering software design fundamentals like Cohesion, Coupling, and Abstraction is a developer's core competitive advantage
• AI is a great productivity tool but should not be hyped as a complete replacement for software development teams