The Free Ride Is Over in Programming

For me, a "free ride" means a guaranteed result in exchange for a fixed amount of effort. School runs on this logic: do your algebra homework, memorize the poem, learn to solve linear equations, and you get an A — the best possible outcome. The love of getting A's has played a cruel trick on many people, because outside educational institutions, free rides barely exist.

The word "easy" later in this article also means a guaranteed result for effort, but the implied meaning is: "easy, if you know how to manage your own motivation."

Six Theses to Set the Stage

Let us examine several theses upfront so we do not need to stop and prove them later. Note that the first three theses may have cause-and-effect relationships with each other, as do theses four and five.

Thesis 1: AI is getting better at routine tasks.

• OpenAI GPT 4.1 models write code better — cheaper, faster, with fewer errors.
• AI suggestions are already being committed into the C++ standard library.
• Since 2019, AI's ability to complete extended tasks has been doubling roughly every seven months.

Thesis 2: AI simplifies development.

• Access to Copilot produced a 13–22% increase in merged pull requests at Microsoft.
• The speed of solving routine programming tasks roughly doubles.

Thesis 3: Virtually all developers now use AI.

• 76% of developers already use AI tools or plan to (with 81% reporting productivity gains).
• 92% of developers in the US use AI at home and at work.
• Free Chinese LLMs at the level of paid ChatGPT o1 were released this year, opening access to developers without money or VPN.

Thesis 4: Large companies have stopped investing in developers.

• Google co-founder Brin said "60 hours a week is the sweet spot of productivity" — a reversal of Google's legendary leniency toward employees.
• Investment in SaaS and enterprise software fell from $17.4 billion in 2023 to $4.7 billion in 2024.
• That money is going to LLMs instead: Amazon — $100B, Google — $75B, Meta — $72B.

Thesis 5: Software developer is no longer a scarce profession.

• Software development job postings fell 51% in 2023 — the sharpest decline of any profession. In 2024 the decline moderated relative to the prior year, but not relative to other professions.

Thesis 6: LLMs are pattern matching, not intelligence.

• LLMs do not think — they simulate thought statistically. They cannot do anything that falls outside their training distribution.
• In MathTrap experiments, GPT-4 and others collapse when problems include "traps" that require combining known rules in new ways.
• At high semantic entropy, responses devolve into "confabulations" — pure statistical noise.

This last thesis seems out of place with the others, but the article's main conclusion rests entirely on it. Let us get to that in order.

Programming Used to Be a Free Ride. It Is Not Anymore.

Not long ago, it was enough to work through a few tutorials, look over some interview examples, grind a couple dozen problems on LeetCode (or Codewars, or HackerRank), and walk into the job market.

It was easy to get by without foundational Computer Science knowledge: data structures and algorithms, databases, operating systems, networking, asymptotic complexity theory.

Even developers who did have a foundation often defined their main job as "translate requirements into code." As this article will argue, there is no longer much value in that.

The free ride is over, and I predict the industry will move away from outsized compensation for solving simple logical puzzles and toward normal pay for genuine competence — competence that will be vetted far more rigorously.

The trend is already visible and being satirized in miniature form everywhere online.

LLMs can now not only help write code but solve certain problems without any programmer involvement at all. It might seem logical to conclude that the barrier to entry in development has dropped.

But it has not. Previously, a junior developer competed with other juniors — who were still developers. Now they also compete with prompt programmers, "vibe coders," and regular developers who cheat with AI in job interviews.

Recruitment has become an arms race at the screening stage itself: recruiters use AI to search resumes, while candidates optimize their resumes with AI.

In this market, the people who do best are those with experience and foundational knowledge. A developer who has already built that foundation also uses AI, but can leverage it with far greater efficiency. For everyone else, the bar has risen extraordinarily.

The Core Delusion of the Vibe Coder

The vibe coder believes that the era has arrived in which companies will pay money for an inability to write code and ignorance of Computer Science fundamentals.

The brutal truth is that era ended precisely when LLMs appeared.

Let me repeat that. With the arrival of LLMs, incompetence stopped being paid for.

The thing is, there was never any real difficulty in solving the majority of tasks on the majority of projects. Yes, you needed some knowledge of the programming language, but that is a matter of one to two weeks. Instead of 1x queries to an LLM you made 2x queries to Google and copied the code — maybe made small edits. No magic happened with LLMs; the search just got faster and the tedious routine disappeared. If the problem has never been solved on the internet, the LLM will not help either. I say this as someone who has used ChatGPT daily since 2022.

There was never any real difficulty in solving the majority of tasks on the majority of projects.

In the past, employers thought programming was hard. Candidates could know and be able to do very little, and still easily find work. You just needed to prepare for the interview, then copy-paste from the internet. I started that way myself and earned good money relative to other fields — without a CS foundation, without algorithmic thinking, without the ability to write clean code.

Today employers understand that routine tasks are easily solved with an LLM and are not prepared to pay much for that. And the number of people wanting to be paid for easy work has increased enormously.

Algorithmic Skills Are Not What Defines a Programmer Today

Even ten years ago, the bulk of work for the vast majority of programmers had nothing to do with algorithms. Mobile developers received JSON and drew "feeds," validating their self-worth by rewriting the architecture to the next acronym (MVC, MVP, MVI, VIPER, MVVM, TEA...). Backend developers shuffled JSON and joined tables, validating their self-worth by carving out microservices and pulling new technologies into the project.

Today, low-level algorithmics is needed even less. When it is clear what to algorithmize — after research and analysis — you can copy-paste a ready solution or ask an LLM to write code from a formal definition. But for that clarity to exist, you need a foundation: algorithm complexity theory, algorithms themselves, and data structures.

I want to make clear: if you have ground through a pile of LeetCode problems, you are no longer a particularly attractive candidate. Artificial toy puzzles are a façade. You need to be able to solve them, but it should not be an end in itself.

And nobody needs — or will very soon not need — a programmer with the attitude: "tell me what to code and I will code it." An LLM does that faster. You now need to know what to code and why.

Framework Knowledge Is Becoming Less Valuable

If you learned a framework from tutorials and solved a dozen LeetCode problems, you are no better than any teenager with ChatGPT.

Prompt programmers today easily handle anything that can be Googled, and anything involving popular frameworks is easily Googled. Basic mistakes like memory leaks or security holes like committing API keys can be caught by configuring an LLM to review your code. I am not sure vibe coders do this, but I recommend it to them above all else.

If the framework does not matter, what does?

• Understanding the framework's limitations — ideally of more than one framework.
• Experience reading and debugging framework source code.
• Experience diagnosing non-obvious problems (for example, tracking down an NDK memory leak in an Android app).
• Experience with complex multi-threaded code.
• Knowledge of the ecosystem: CI/CD, tooling, deployment, profiling skills.

None of this can be obtained from tutorials or by consulting ChatGPT during development — especially when you need to make an architectural decision. Because you will not know how good that consultation actually is. LLMs hallucinate and have cognitive biases, and you may make a decision based on incorrect LLM conclusions.

The Technical Skills Scale for a Programmer Today

I see a programmer's technical skills in this order of priority:

1. The ability to design and scale system architecture.
2. Foundational Computer Science knowledge.
3. The ability to write maintainable code regardless of language.
4. The ability to write code in a specific language.
5. The ability to solve algorithmic problems.

The critical point: items 1–3 matter enormously; items 4–5 barely matter at all.

Architecture and scalability are fundamental because they determine cost predictability, reliability with SLAs, development velocity, and long-term maintainability of a system.

Foundational knowledge is growing in demand precisely because coding skills and framework knowledge are easily supplemented by AI — while understanding CS fundamentals allows you to:

• Solve problems that an LLM cannot.
• Review what the AI writes and immediately spot problems.
• Understand new frameworks, databases, DevOps tools and other technologies faster.
• Use LLMs more effectively (give more precise instructions).

It is important that the codebase "ages" well. In other words, you need to minimize accidental complexity, because otherwise the project becomes physically unmaintainable over time — solving one problem spawns two others (the hydra).

Items 4 and 5 barely matter because they are easily handled by LLM and will be handled even better over time. Non-idiomatic code and language-specific issues can be caught in review by the same LLMs. The exception: moving from a high-level language (JS) to a low-level one (C++). LLMs do not help there, but that falls under item 2 (foundational knowledge), since JS does not require thinking about threads or memory.

Interviews still prioritize items 4 and 5. This is a mistake by companies. They should either allow LLM use during interviews and pay attention to what the person notices and how they reason — or stop wasting both sides' time on algorithmic puzzles altogether.

Why Understanding the Business Matters

Some programmers — and I include my past self here — are indifferent to business. Thinking about business is not interesting; writing code and exploring technologies is interesting.

Some openly say they are happy to pull "unnecessary" technologies into a project because it is interesting and useful for the CV. CV-driven development. And the pain of the next generation who has to maintain it.

Businesses ultimately pay for value. There is little value in the CV-driven idea above, and little in "coding" a task that has been described in minute detail. Anyone with an LLM can do that.

There is more value in the ability to make quality architectural decisions. These tasks are harder and require not only experience and technical awareness but understanding of the domain. Otherwise how do you answer questions like:

• Should music playback in this Android app use WebView, MediaPlayer, or ExoPlayer?
• Do we need backend-driven UI?
• Should we insist on adding pagination to the API design right now?
• Monolith, services, or microservices?
• If microservices, how do we split them to avoid a distributed monolith?

The point is not loyalty to business but loyalty to the profession. Good decisions come from good understanding of context.

Closing Thoughts

A superficial look at programming can create the illusion of an easy entry point for anyone willing to try. In reality, it has become significantly harder — both to start and to continue. It is harder to reliably exchange a small set of skills for good compensation.

Beginner developers — especially prompt programmers — think: "I'll go work as a programmer without CS fundamentals or coding skills." But that was actually easier in the past, not now.

The market now demands more preparation from programmers for less compensation. The value of competence has risen because LLMs can only solve routine tasks, while non-routine tasks require knowledge and skill.

But even if you have experience and knowledge, you still have to compete against a wave of people inflating their credentials and passing interviews with LLM assistance.

What should you do? Stay in programming if you love it — not because the money is easy. Invest more in fundamentals and less in frameworks. Follow your genuine curiosity.

P.S. Based on the comments, some people think this article says programmers are no longer needed. The thesis is precisely the opposite. LLMs are just a tool for routine tasks.