ai is ruining the art of programming

niels jaspers • may 28, 2025

it's almost impossible to miss the buzz these days around "artificial intelligence," or ai for short. ai can do all sorts of things: summarize text, explain topics while impersonating napoleon bonaparte, and create images of cats on toilets reading a newspaper. but one of its most common applications, especially in my field, is programming.

this often involves using tools like chatgpt, github copilot, claude, and others. you ask the chatbot to create something, it generates code, and you repeat this process until you have a functioning app.

you might think, "yeah, that's awesome! now everyone can be a programmer!" and you'd be right. however, there's a small problem...

the canvas and the code

one of the reasons i got into computer science was because i found it fascinating how, by typing some words on a screen, i could make the computer do things. that moment was special. i could command a computer to do exactly as i said with just words. of course, computers are much more complicated than that, but that first infinite 'hello world' loop in python remains special.

this feeling of creation is like how an artist approaches a blank canvas. programming can be a form of expressing yourself, just like how an artist would with a painting. this can be as high-level as what programming language you choose, down to the way you structure your variables. but the 'programming' part isn't the only art. in my opinion, the unique way you solve problems when coding is also a significant art form. it's like an artist choosing a specific brushstroke or color palette to convey a particular emotion.

but this is changing with the recent developments around ai, with the new concept of "vibe coding."

embracing the "vibes", and the bugs

the concept of "vibe coding" was introduced by andrej karpathy (@karpathy), an ai researcher. it's described as a new way to develop software, where programmers explain what they want to create in natural language, and ai tools generate the code. using this method, anyone can program without needing prior knowledge of traditional coding, where understanding the code is crucial for maintenance and debugging.

supporters of "vibe coding" often highlight that this new ai-driven method leads to faster development cycles and greater accessibility for people outside the tech field. however, opponents caution about the risks associated with "vibe coding" and responsible software development. relying entirely on ai presents several challenges. if a project exceeds the ai's context window, the ai may struggle to maintain the entire project in its memory, leading to errors.

these errors can range from minor bugs to significant vulnerabilities. a notable example occurred in march 2025 when a twitter user, leojr94_, tweeted about creating their saas entirely with cursor, despite having no prior programming knowledge. just two days later, they reported being "under attack," with people bypassing subscriptions and gaining unauthorized access to their database. however, these bugs and vulnerabilities are just one aspect of the problem. while security breaches and technical failures grab headlines, they represent symptoms of a deeper issue.

the more fundamental concern lies in what "vibe coding" does to our capacity for critical thinking. not just as programmers, but as problem-solvers in an increasingly ai-dependent world.

the concerning impact on critical thinking

traditional programming is tightly connected with creative problem solving. developers get confronted with challenges that require innovative approaches and critical thinking to come up with efficient solutions. this process includes understanding the problem, coming up with possible solutions, prototyping, and testing the implementation. these steps demand deep analysis, logical reasoning, and creative "out-of-the-box thinking." all of these steps, however, are bypassed with "vibe coding". this shift raises a concerning question: what happens to our ability to think critically when we no longer need to exercise these mental muscles? the implications extend far beyond tech, touching every sector where ai can be deployed.

when programmers rely heavily on ai to generate solutions, they risk becoming passive consumers rather than active problem-solvers. the muscle of breaking down complex problems into smaller, manageable pieces begins to atrophy. without regularly exercising the mental processes of debugging, optimizing, and understanding trade-offs between different approaches, developers may find themselves helpless when ai-generated code fails or when they encounter problems that fall outside the ai's training data.

this phenomenon extends beyond programming. in mathematics, students who rely too heavily on (ai) calculators may struggle with number sense and mental arithmetic. similarly, writers who depend entirely on ai for content creation may lose their ability to craft compelling narratives or develop their unique voice. the pattern is clear: when we outsource our thinking to machines, we risk losing the very skills that make us valuable as humans.

the irony is that while ai makes programming more accessible to beginners, it may paradoxically make experienced programmers less capable over time. the next generation of developers might know how to prompt an ai effectively but struggle to understand why their code works, or more importantly, why it doesn't. this creates a dangerous dependency where the tools meant to enhance our capabilities instead replace them entirely.

reclaiming the art: a call for balance

the rise of ai in programming presents us with a crossroads. we can choose the path of least resistance, letting ai handle the complexities while we become mere coordinators of generated code. or we can choose to preserve what makes programming truly rewarding: the intellectual challenge, the problem-solving journey, and the satisfaction of building something with our own understanding.

this isn't a call to abandon ai entirely. these tools can be extremely powerful allies when used thoughtfully: helping with boilerplate code, suggesting optimizations, or serving as a rubber duck for debugging. the key is maintaining agency over the creative process rather than surrendering it completely.

what makes us uniquely human in the age of ai isn't just our ability to write code, but our curiosity to understand why things works. our drive to explore unconventional solutions. our capacity to learn from failures and build intuition over time. these qualities can't be replicated by pattern-matching algorithms, no matter how sophisticated.

the blank canvas of a new project should still inspire wonder, not prompt us to immediately reach for an ai crutch. the debugging session that keeps us up at night should be seen as a puzzle to solve, not a task to delegate. the moment when a complex algorithm finally clicks in our minds remains irreplaceable, and it's worth fighting to preserve.

programming has always been about more than just making computers do things. it's about expanding our own capacity to think, to solve problems, and to create. let's not trade that birthright for the convenience of having our thinking done for us. the art of programming is worth preserving, one carefully crafted line of code at a time.