Why Does AI Coding Feel Frustrating to Developers?

TL;DR

AI coding becomes frustrating when unpredictable outputs replace the logical, repeatable process that makes programming satisfying. Large generated changes can require repeated prompting, correction, testing, and workflow adjustments, while manual coding and inline completion preserve more control. The practical standard is whether AI helps you enjoy the craft, improve your skills, and work faster after accounting for its adoption costs.

Transcript

For those that don't know, this is Coding Garden. Awesome streamer on Twitch. He's obviously on the Syntax FM podcast. If you don't know them, great little channel right here. You can go check this out about my thoughts and uh you can tell me what your thoughts are. Also, this title is called AI Coding Sucks. And I just want to let you guys know I ... Read More

Key Insights

• Programming is rewarding when difficult bugs, features, or concepts lead to small wins and a sense of earned progress. When an LLM supplies the solution, a developer may lose that reward and instead remember the corrections, arguments, and failed attempts required to obtain usable code.
• LLM-generated code is unpredictable because the same prompt can produce different responses. This conflicts with the appeal of programming as a logical and knowable activity in which documentation, source code, decompilation, and network traffic can help establish how a system behaves.
• Inline AI completion is more acceptable when it predicts a small amount of code from nearby context. It can handle routine details such as a for loop while allowing the developer to structure the system manually, retain control, and remain closely involved in implementation decisions.
• The value of an AI workflow depends on whether it improves both craftsmanship and enjoyment. A developer who produces more code but stops learning, feels detached from the work, or continually struggles through unfamiliar concepts may be creating long-term difficulties rather than sustainable progress.
• Early AI adopters pay a workflow cost by learning prompts, context strategies, custom rules, model-specific techniques, and corrective rituals. These techniques can become obsolete, just as older JavaScript performance practices became unnecessary or counterintuitive as technology and runtime behavior changed.
• Prompt incantations are a sign of unreliable tooling when ordinary expectations require special phrasing. Developers should not need to append instructions such as avoiding mistakes or producing secure code, yet reported workflows often depend on precisely worded directions whose effectiveness can vary.
• Hosted AI models can change without giving developers control over those changes. A service may retain a familiar name while its outputs shift because the provider continually tweaks the model, making previously successful prompts and workflows less dependable over time.
• Claims of a 100x productivity improvement are rejected through a time comparison. Such a claim would mean that three and a half days with AI equal roughly one year of full-time work, an implication presented as implausible rather than a credible measure of ordinary development productivity.

Questions & Answers

Q: Why does AI coding feel frustrating to developers?

AI coding can feel frustrating because an LLM does not behave like the logical systems developers are accustomed to controlling. The same prompt can yield different answers, generated code may repeatedly miss the request, and successful workflows can later stop working. Instead of solving a problem and enjoying a small win, the developer may spend time correcting output, rewriting instructions, and becoming angry with an unpredictable tool.

Q: How does AI coding affect the satisfaction of programming?

Programming can provide satisfaction through earned progress: a developer works through a bug, understands a system, builds a feature, and receives a small emotional reward when it works. When an LLM performs the central reasoning or implementation, that sense of ownership may disappear. The developer can be left with the least enjoyable parts, including reviewing mistakes, explaining the request again, and cycling through revisions without feeling that personal skill produced the result.

Q: Why are LLM workflows less predictable than traditional programming?

Traditional programming uses formal, logical languages and systems whose behavior can be investigated through documentation, source code, decompilation, or network traffic. An LLM is based on statistical prediction and may provide different responses to the same prompt. That difference makes it harder to establish a repeatable workflow, because a prompt or context strategy that succeeds once may produce another result later, even when the developer believes the inputs are unchanged.

Q: When is inline AI completion useful for coding?

Inline AI completion is useful when it predicts a small, local piece of code from the surrounding context while the developer retains responsibility for the broader structure. Routine code, such as a for loop, does not necessarily need to be typed manually. This approach can preserve the pleasure and control of constructing the system while reducing repetitive typing, making it more comfortable than delegating large sections of implementation to generated output.

Q: What is the early adopter tax for AI coding tools?

The early adopter tax is the time and effort required to integrate immature or shifting AI workflows. Developers may need to learn special prompts, context techniques, custom rules, testing procedures, and model-specific behaviors before seeing a speed increase. Those methods can later stop working or become unnecessary. The transcript compares this burden with old JavaScript optimization practices that newer developers did not need to learn because the relevant technical conditions eventually changed.

Q: How should developers decide whether to use AI for coding?

Developers should evaluate whether AI helps them enjoy their craft, improve their abilities, and complete work effectively after counting the full workflow cost. Faster output alone is not enough if the process causes persistent frustration or prevents learning. If AI supports growth and enjoyment, using it can be reasonable. If it leaves the developer detached, confused, and dependent on generated answers, the workflow may create long-term problems despite apparent short-term productivity.

Q: Why can a successful AI coding prompt stop working?

A successful prompt can stop working because the developer does not control the hosted model and the provider may continually tweak it. The service can keep the same public model name while producing different outputs. In addition, LLM responses are inherently variable, so identical wording does not guarantee identical code. As a result, model-specific prompts, custom rules, or context workflows may be effective temporarily without becoming stable engineering procedures.

Q: Why is a 100x AI coding productivity claim criticized?

A 100x productivity claim is criticized because its time implication is presented as implausible. At that rate, three and a half days of work with AI would equal approximately one year of full-time work without it. The reaction argues that ordinary developers should be capable of producing within a year what an AI-assisted person creates in that short period, so such a multiplier is treated as exaggeration rather than a realistic productivity measurement.

Summary & Key Takeaways

• Programming feels rewarding when solving a bug or building a feature produces a clear sense of accomplishment. Delegating that work to an LLM can remove this satisfaction because the developer may feel no ownership of the solution. The remaining experience can become a frustrating cycle of reviewing incorrect output and requesting revisions.

• Traditional programming is appealing because logical systems can be investigated through documentation, source code, decompilation, or network traffic. LLM behavior is less predictable because identical prompts can return different responses. That stochastic behavior makes stable workflows difficult to build, especially when models or hosted services change while retaining the same public name.

• AI adoption should be judged by its complete effect on productivity, enjoyment, and learning. Prompt techniques, custom rules, testing, corrections, and changing model behavior impose an early adopter cost that can offset theoretical speed gains. Inline completion may offer a useful compromise because it accelerates small tasks while leaving structure and decisions with the developer.