Vibecoding: The Controversial Art of Letting AI Write Your Code – Friend or Foe?
Introduction: Decoding the "Vibe" in Coding
The landscape of software development is undergoing a seismic shift, driven in large part by the rapid advancements in artificial intelligence. Tools like GitHub Copilot, ChatGPT, and others are moving beyond simple autocompletion and static analysis, offering developers the ability to generate significant blocks of code based on high-level descriptions or even just conversational prompts. This emerging practice, sometimes colloquially referred to as "vibecoding," is sparking intense debate across the industry.
At its surface, "vibecoding" suggests generating code based on intuition or a general "vibe" of what's needed, rather than through painstaking, line-by-line construction rooted in deep technical specification. This isn't about replacing developers entirely, but about dramatically changing how code is written and who can participate in the process. On one hand, proponents hail it as a revolutionary leap in productivity, capable of democratizing coding and accelerating development timelines. On the other, critics voice significant concerns, warning of potential pitfalls related to code quality, security, and the very nature of learning and practicing software engineering.
Is "vibecoding" a shortcut that leads to fragile, insecure code, or is it a powerful new tool in the experienced developer's arsenal? Does it fundamentally undermine the foundational skills necessary for truly understanding and building robust systems, or is it simply the next evolution of abstraction layers in software? This article will delve into these questions, exploring what "vibecoding" actually entails, the valid criticisms leveled against it (particularly concerning new developers), the potential benefits it offers to veterans, the deeper controversies it raises, and ultimately, how the industry might navigate this complex new terrain.
To illustrate the core idea of getting code from a simple description, let's consider a minimal example using a simulated AI interaction:
# Simulate a basic AI generation based on a prompt prompt = "Python function to add two numbers" # In a real scenario, an AI model would process this. # We'll just provide the expected output for this simple prompt. ai_generated_code = """ def add_numbers(a, b): return a + b """ print("Simulated AI Generated Code based on prompt:") print(ai_generated_code)
Analysis of Code Interpreter Output:
The Code Interpreter output shows a very basic example of what "vibecoding" conceptually means: a simple prompt ("Python function to add two numbers") leading directly to functional code. While this is trivial, it highlights the core idea – getting code generated without manually writing every character. The controversy, as we'll explore, arises when the tasks become much more complex and the users' understanding of the generated code varies widely. This initial glimpse sets the stage for the deeper discussion about the implications of such capabilities.
Okay, here is the second section of the technical blog post, focusing on defining the concept of "vibecoding."
What Exactly is "Vibecoding," Anyway? Defining the Fuzzy Concept
Building on our introduction, let's nail down what "vibecoding" means in the context of this discussion. While the term itself lacks a single, universally agreed-upon definition and can sound dismissive, it generally refers to the practice of using advanced generative AI tools to produce significant portions of code from relatively high-level, often informal, descriptions or prompts. This goes significantly beyond the familiar territory of traditional coding assistance like intelligent syntax highlighting, linting, or even context-aware autocomplete that suggests the next few tokens based on the surrounding code.
Instead, "vibecoding" leans into the generative capabilities of large language models (LLMs) trained on vast datasets of code. A developer might provide a prompt like "write a Python function that fetches data from this API endpoint, parses the JSON response, and saves specific fields to a database" or "create a basic React component for a button with hover effects and a click handler." The AI then attempts to generate the entire code block necessary to fulfill that request. The "vibe" in "vibecoding" captures this less formal, often more experimental interaction style, where the developer communicates their intent or the desired outcome without necessarily specifying the intricate step-by-step implementation details. They're trying to get the AI to grasp the overall "vibe" of the desired functionality.
It's crucial to distinguish "vibecoding" from "no-code" or "low-code" platforms. No-code platforms allow users to build applications using visual interfaces and pre-built components without writing any code at all. Low-code platforms provide visual tools and abstractions to reduce the amount of manual coding needed, often generating standard code behind the scenes that the user rarely interacts with directly. "Vibecoding," however, operates within the realm of traditional coding. The AI generates actual code (Python, JavaScript, Java, etc.) that is then incorporated into a standard codebase. The user still needs a development environment, still works with code files, and still needs to understand enough about the generated code to integrate it, test it, and debug it. But even this is changing with the rise of tools that allow users to interact with AI in a more conversational manner, blurring the lines between traditional coding and no-code/low-code paradigms. Look at Google's Firebase Studio, which allows users to build applications using a combination of conversational tools and code generation. This is a step towards a more integrated approach to development, where the boundaries between coding and no-coding are increasingly challenged.
As an example, without writing a single line of code, nor even looking at the code, I was able to generate a simple, one level, grid based game. The game is called "Cubicle Escape" where the user (an "office worker") has to collect memes that scattered around the office, all while avoiding small talk with coworkers and staying away from the boss. You should probably also avoid the breakroom where someone is currently microwaving fish for lunch.
It is written in Next.js, and uses TypeScript for language.
The level of AI assistance in coding exists on a spectrum. At the basic end are tools that offer single-line completions or expand simple abbreviations. Moving up, you have AI that suggests larger code blocks or completes entire functions based on the function signature or comments. "Vibecoding," as we use the term here, typically refers to the higher end of this spectrum: generating multiple lines, full functions, classes, configuration snippets, or even small, self-contained modules based on prompts that describe what the code should do, rather than how it should do it, leaving significant implementation details to the AI.
Let's see a simple conceptual example of generating a small code structure based on a higher-level intent, the kind of task that starts moving towards "vibecoding":
# Simulate an AI generating a simple data class structure based on attributes class_name = "Product" attributes = {"name": "str", "price": "float", "in_stock": "bool"} # --- Simulate AI Generation Process --- generated_code = f"class {class_name}:\n" generated_code += f" def __init__(self, name: {attributes['name']}, price: {attributes['price']}, in_stock: {attributes['in_stock']}):\n" for attr, dtype in attributes.items(): generated_code += f" self.{attr} = {attr}\n" generated_code += "\n def __repr__(self):\n" generated_code += f" return f\"{class_name}(name='{{self.name}}', price={{self.price}}, in_stock={{self.in_stock}})\"\n" generated_code += "\n def __eq__(self, other):\n" generated_code += " if not isinstance(other, Product):\n" generated_code += " return NotImplemented\n" generated_code += " return self.name == other.name and self.price == other.price and self.in_stock == other.in_stock\n" print("--- Simulated AI Generated Code ---") print(generated_code) # --- Example Usage (Optional, for verification) --- # try: # exec(generated_code) # p1 = Product("Laptop", 1200.50, True) # print("\n--- Example Usage ---") # print(p1) # except Exception as e: # print(f"\nError during execution: {e}")
Analysis of Code Interpreter Output:
The output from the Code Interpreter demonstrates the generation of a basic Python Product class. The input was a class name and a dictionary of attributes and their types. The "AI" (our simple script) then generated the __init__, __repr__, and __eq__ methods based on this input. This is a step above just suggesting the next few characters; it generates a full structural unit based on a declarative description ("I want a class with these attributes"). This kind of task—generating common structures or boilerplate from a simple prompt—is central to what's often meant by "vibecoding," and as we'll explore, it's here that the line between helpful tool and potential crutch becomes evident, particularly depending on the user's expertise.
Okay, here is the third section of the technical blog post, focusing on the negative implications of "vibecoding" for beginners, incorporating the use of the code_interpreter.
The Dark Side: Why "Vibecoding" Can Be Detrimental for Beginners
While the allure of rapidly generating code via AI is undeniable, particularly the notion of "vibecoding" where a high-level intent translates directly into functional lines, this approach harbors a significant risk, especially for those just starting their journey in software engineering. The most potent criticism of "vibecoding," and indeed its negative "kernel," is the potential for it to undermine the fundamental learning process that is crucial for building a solid engineering foundation.
Software engineering isn't just about writing code; it's about understanding how and why code works, how to structure it effectively, and how to anticipate and handle potential issues. This understanding is traditionally built through the arduous, yet invaluable, process of manual coding: typing out syntax, struggling with control flow, implementing data structures from scratch, and battling algorithms until they click. Relying on AI to instantly generate code bypasses this crucial struggle. Beginners might get a working solution for a specific problem posed to the AI, but they miss the repetitive practice required to internalize syntax, the logical reasoning needed to construct loops and conditionals, and the manual manipulation of data structures that cements their understanding. This leads to Fundamental Skill Erosion, where the core mechanics of programming remain shallow.
This shortcut fosters a profound Lack of Code Comprehension. When a beginner receives a block of AI-generated code, it can feel like a "black box." They see that it performs the requested task but lack the intricate knowledge of how it achieves this. They may not understand the specific library calls used, the nuances of the algorithm implemented, or the underlying design patterns. This makes modifying the code incredibly challenging. If the requirements change slightly, they can't tweak the existing code; they often have to go back to the AI with a new prompt, perpetually remaining at the mercy of the tool without developing the ability to independently adapt and evolve the codebase.
Consequently, Debugging Challenges become significantly amplified. All code has bugs, and AI-generated code is no exception. These bugs can be subtle – edge case failures, off-by-one errors, or incorrect assumptions about input data. Debugging is one of the most critical skills in software engineering, requiring the ability to trace execution, inspect variables, read error messages, and form hypotheses about what went wrong. When faced with a bug in AI-generated code they don't understand, a beginner is ill-equipped to diagnose or fix the problem. The "black box" turns into an impenetrable wall, leading to frustration and an inability to progress.
Furthermore, AI models, while powerful, don't inherently produce perfect, production-ready code. They might generate inefficient algorithms, unconventional coding styles, or solutions that don't align with a project's architectural patterns. For a beginner who lacks the experience to evaluate code quality, these imperfections are invisible. Blindly integrating such code leads directly to the Introduction of Technical Debt – code that is difficult to read, maintain, and scale. This debt accumulates silently, potentially crippling a project down the line, and the beginner contributing it might not even realize the problem they're creating.
Perhaps most critically, over-reliance on AI for generating solutions hinders the development of essential Problem-Solving Skills. Software development is fundamentally about deconstructing complex problems into smaller, manageable parts and devising logical steps to solve each part. When an AI is prompted to solve a problem from start to finish, the beginner misses the entire process of problem decomposition, algorithmic thinking, and planning the implementation steps. They receive an answer without having practiced the crucial skill of figuring out how to arrive at that answer.
Ultimately, "vibecoding" as a primary method of learning leads to Missed Learning Opportunities. The struggle – writing a loop incorrectly five times before getting it right, spending hours debugging a misplaced semicolon, or refactoring a function to make it more readable – is where deep learning happens. These challenges build resilience, intuition, and a profound understanding of how code behaves. By providing immediate, albeit potentially flawed or opaque, solutions, AI shortcuts this vital part of the learning curve, leaving beginners with a superficial ability to generate code but lacking the foundational understanding and problem-solving acumen required to become proficient, independent engineers.
Let's use the Code Interpreter to illustrate a simple task and how an AI might generate code that works for a basic case but misses common real-world considerations, highlighting what a beginner might not learn to handle.
# Simulate an AI being asked to write a function to calculate the sum of numbers from a file # This simulation will generate a basic version lacking robustness file_content_basic = "10\n20\n30\n" file_content_mixed = "10\nhello\n30\n" non_existent_file = "non_existent.txt" basic_file = "numbers_basic.txt" mixed_file = "numbers_mixed.txt" # Write simulated file content for demonstration with open(basic_file, "w") as f: f.write(file_content_basic) with open(mixed_file, "w") as f: f.write(file_content_mixed) # --- Simulate AI Generated Function --- def sum_numbers_from_file(filepath): """ Reads numbers from a file, one per line, and returns their sum. (Simulated basic AI output - potentially brittle) """ total_sum = 0 with open(filepath, 'r') as f: for line in f: total_sum += int(line.strip()) # Assumes every line is a valid integer return total_sum print("--- Attempting to run simulated AI code on basic input ---") try: result_basic = sum_numbers_from_file(basic_file) print(f"Result for '{basic_file}': {result_basic}") except Exception as e: print(f"Error running on '{basic_file}': {e}") print("\n--- Attempting to run simulated AI code on input with mixed data ---") try: result_mixed = sum_numbers_from_file(mixed_file) print(f"Result for '{mixed_file}': {result_mixed}") except Exception as e: print(f"Error running on '{mixed_file}': {e}") print("\n--- Attempting to run simulated AI code on non-existent file ---") try: result_non_existent = sum_numbers_from_file(non_existent_file) print(f"Result for '{non_existent_file}': {result_non_existent}") except Exception as e: print(f"Error running on '{non_existent_file}': {e}") # Clean up simulated files import os os.remove(basic_file) os.remove(mixed_file)
Analysis of Code Interpreter Output:
The Code Interpreter successfully ran the simulated AI-generated function on the basic file, producing the correct sum (60). However, when attempting to run it on the file with mixed data (numbers_mixed.txt), it correctly produced a ValueError because it tried to convert the string "hello" to an integer using int(). Crucially, when run on the non_existent.txt file, it raised a FileNotFoundError.
This output starkly illustrates the potential pitfalls for a beginner relying on "vibecoding." The AI might generate code that works for the ideal case (file exists, contains only numbers). A beginner, seeing this work initially, might assume it's robust. They wouldn't have learned to anticipate the ValueError from invalid data or the FileNotFoundError from a missing file because they didn't build the logic step-by-step or consider potential failure points during manual construction. They also likely wouldn't know how to add try...except blocks to handle these common scenarios gracefully. The errors encountered in the CI output are the very learning moments that are bypassed by simply receiving generated code, leaving the beginner vulnerable and lacking the skills to create truly robust applications.
The Silver Lining: How AI Assistance Empowers Veteran Engineers
While the risks of "vibecoding" for beginners are substantial, presenting a valid concern about skill erosion, the very same AI capabilities reveal a potent "silver lining" when considered from the perspective of experienced software engineers. For veterans, AI-assisted coding tools aren't about learning the fundamentals they already command; they are about augmenting their existing expertise and significantly boosting productivity. The positive "kernel" within the concept of generating code from high-level intent lies in its power as an acceleration tool for those who already understand the underlying mechanics.
Veteran engineers possess a deep reservoir of knowledge built over years of practice. They understand syntax, algorithms, data structures, design patterns, and debugging methodologies. They have battled complex problems and built robust systems. For this audience, AI tools act less like a teacher providing the answer and more like an incredibly efficient co-pilot or a highly knowledgeable assistant. The "vibe" they give the AI isn't born of ignorance, but of a clear understanding of the desired outcome, allowing the AI to handle the mechanical translation of that intent into standard code patterns.
One of the most immediate and impactful benefits for experienced developers is Boilerplate Generation. Every software project, regardless of language or framework, involves writing repetitive, predictable code structures. Think about defining a new class with standard getters and setters, setting up basic configurations, creating common database migration scripts, or structuring the initial files for a framework component (like a React component skeleton or a Django model). These are tasks a veteran knows exactly how to do, but typing them out manually takes time and is prone to minor errors. AI can instantly generate this boilerplate based on a simple description, freeing up the engineer to focus on the unique business logic.
Let's revisit our simple class generation example from earlier, this time viewing it through the lens of a veteran engineer using AI for boilerplate:
# Simulate an AI generating a simple data class structure based on attributes # This time, imagine a veteran engineer is the user, providing the requirements class_name = "ConfigurationItem" attributes = {"key": "str", "value": "any", "is_sensitive": "bool", "last_updated": "datetime.datetime"} # More complex types # --- Simulate AI Generation Process --- # An AI would typically generate this based on a prompt like "create a Python class # ConfigurationItem with attributes key (str), value (any), is_sensitive (bool), # and last_updated (datetime.datetime), include typical methods." generated_code = f"import datetime # AI recognizes need for datetime\n\n" # AI adds necessary imports generated_code += f"class {class_name}:\n" generated_code += f" def __init__(self, key: {attributes['key']}, value: {attributes['value']}, is_sensitive: {attributes['is_sensitive']}, last_updated: {attributes['last_updated']}):\n" for attr, dtype in attributes.items(): generated_code += f" self.{attr} = {attr}\n" generated_code += "\n def __repr__(self):\n" generated_code += f" return f\"{class_name}(key='{{self.key}}', value={{self.value!r}}, is_sensitive={{self.is_sensitive}}, last_updated={{self.last_updated!r}})\" # Using !r for repr\n" generated_code += "\n def __eq__(self, other):\n" generated_code += f" if not isinstance(other, {class_name}):\n" generated_code += " return NotImplemented\n" generated_code += " return self.key == other.key and self.value == other.value and self.is_sensitive == other.is_sensitive and self.last_updated == other.last_updated\n" generated_code += "\n def to_dict(self):\n" # Adding a common utility method as boilerplate generated_code += " return {\n" for attr in attributes.keys(): generated_code += f" '{attr}': self.{attr},\n" generated_code += " }\n" print("--- Simulated AI Generated Code for Veteran ---") print(generated_code) # --- Veteran Verification (Conceptual) --- # A veteran would quickly scan this output: # - Is the import correct? Yes. # - Are the attributes assigned correctly in __init__? Yes. # - Are __repr__ and __eq__ implemented reasonably for a data class? Yes. # - Is the to_dict method structure correct? Yes. # - Are there any obvious syntax errors? No. # The veteran would then integrate this, potentially tweak variable names, add docstrings, etc.
--- Simulated AI Generated Code for Veteran --- import datetime # AI recognizes need for datetime class ConfigurationItem: def __init__(self, key: str, value: any, is_sensitive: bool, last_updated: datetime.datetime): self.key = key self.value = value self.is_sensitive = is_sensitive self.last_updated = last_updated def __repr__(self): return f"ConfigurationItem(key='{self.key}', value={self.value!r}, is_sensitive={self.is_sensitive}, last_updated={self.last_updated!r})" # Using !r for repr def __eq__(self, other): if not isinstance(other, ConfigurationItem): return NotImplemented return self.key == other.key and self.value == other.value and self.is_sensitive == other.is_sensitive and self.last_updated == other.last_updated def to_dict(self): return { 'key': self.key, 'value': self.value, 'is_sensitive': self.is_sensitive, 'last_updated': self.last_updated, }
Analysis of Code Interpreter Output:
The simulated AI-generated code produced a ConfigurationItem class with the specified attributes, including an import for datetime and standard __init__, __repr__, __eq__, and to_dict methods. For a veteran engineer, this output represents a significant time saver. They would instantly recognize the generated code as correct boilerplate. Unlike a beginner, they don't need to understand how the AI generated it; they understand the structure and purpose of the generated code perfectly. They can quickly review it, confirm it meets their needs, and integrate it, potentially adding docstrings or minor tweaks. This moves the veteran past the tedious typing phase straight to the more critical tasks.
This capability extends to Handling Framework Idiosyncrasies. Frameworks often have specific decorators, configuration patterns, or API usage conventions that are standard but require looking up documentation or recalling specific patterns. An AI, trained on vast code repositories, can quickly generate code snippets conforming to these patterns, even for less common or recently introduced framework features. This reduces the mental overhead of context switching and searching documentation.
Fundamentally, AI assistance for veterans is about Reducing Cognitive Load on repetitive and predictable tasks. By automating the writing of mundane code, the engineer's mind is free to concentrate on the truly complex aspects of the project: the architecture, the intricate business logic, performance optimization, security considerations, and overall system design. This allows them to work at a higher level of abstraction, tackling more challenging problems more efficiently.
AI also facilitates Accelerated Prototyping. When exploring a new idea or testing a potential solution, a veteran can use AI to rapidly generate proof-of-concept code or basic implementations of components needed for testing, speeding up the experimentation process.
Furthermore, when exploring unfamiliar Languages or Libraries, AI can quickly provide basic "getting started" examples or common usage patterns, helping a veteran quickly grasp the syntax and typical workflow without extensive initial manual coding and documentation deep dives.
Crucially, the key differentiator between a beginner and a veteran using AI is Emphasis on Verification. An experienced engineer doesn't blindly copy and paste AI-generated code. They treat it as a suggestion or a first draft. They review it critically, checking for correctness, efficiency, adherence to coding standards, and potential security issues. They understand the potential for AI "hallucinations" or the generation of suboptimal code and have the skills to identify and correct these issues. The AI empowers them by providing a rapid starting point, but their expertise is essential for validating and refining the output.
In essence, for the veteran, AI-assisted coding is a powerful force multiplier. It removes friction from the coding process, allowing them to leverage their deep understanding and problem-solving skills more effectively by offloading the mechanical aspects of code writing. This contrasts sharply with the beginner, for whom the same process can bypass the very steps needed to build that deep understanding in the first place.
Deeper Concerns: Beyond the Beginner vs. Veteran Debate
While the discussion around how "vibecoding" affects the skill development of novice versus experienced engineers is crucial, the integration of AI-assisted code generation into our workflows raises several other significant challenges that extend beyond individual developer capabilities. These are concerns that impact entire development teams, organizations, and the broader software ecosystem, touching upon fundamental aspects of software reliability, legal frameworks, ethical responsibilities, and even sustainability.
A primary area of concern revolves around security vulnerabilities. AI models learn from vast datasets of code, and unfortunately, not all publicly available code adheres to robust security practices. This means that AI can inadvertently generate code snippets that contain common, exploitable flaws. Examples include inadequate input validation opening the door to injection attacks (like SQL or command injection), insecure default configurations, or the incorrect implementation of cryptographic functions. Compounding this, AI might occasionally generate code that references non-existent libraries or packages. This phenomenon has led to the term "slopsquatting," where malicious actors create packages with names similar to these AI "hallucinations," tricking developers who blindly trust AI suggestions into introducing malware into their projects. The presence of these potential vulnerabilities necessitates rigorous human review and security analysis, regardless of the developer's comfort level with the tool.
Let's demonstrate a simplified conceptual example of how an AI might generate code that could introduce a security flaw if not carefully vetted.
# Simulate an AI being asked to generate code to run a command based on user input # This simulation will show how it might create a command injection vulnerability def simulate_execute_command(user_input_filename): """ Simulates generating a command string for processing a file. (Simplified AI output - potentially vulnerable) """ # In a real scenario, this command might be executed using os.system or subprocess.run(shell=True) command = f"processing_tool --file {user_input_filename}" return command # --- Test cases --- safe_input = "my_report.txt" malicious_input = "my_report.txt; ls -l /" # Attempting command injection print("--- Simulated AI Generated Commands ---") safe_command = simulate_execute_command(safe_input) print(f"Input: '{safe_input}' -> Generated Command: '{safe_command}'") malicious_command = simulate_execute_command(malicious_input) print(f"Input: '{malicious_input}' -> Generated Command: '{malicious_command}'") # Simple check (not a foolproof security analysis, just for demonstration) if ";" in malicious_command or "&" in malicious_command or "|" in malicious_command: print("\n--- Analysis ---") print("The generated command for malicious input contains special characters (;, &, |) that could indicate a command injection vulnerability if this string is directly executed via a shell.")
Analysis of Code Interpreter Output:
The Code Interpreter output shows that the simulated function correctly generates the command string for the safe input. However, for the malicious input "my_report.txt; ls -l /", it generates the string "processing_tool --file my_report.txt; ls -l /". Our simple check correctly identifies the presence of the semicolon, highlighting the potential for a command injection vulnerability if this string were passed directly to a shell execution function in a real application. This example demonstrates how an AI might generate code that is functionally correct for the "happy path" but critically insecure in the face of adversarial input – a risk that requires human security expertise to identify and mitigate.
Beyond security, significant legal and ethical implications loom large. The training data for these models often includes publicly available code, sometimes with permissive licenses, but the sheer scale raises questions. Who holds the copyright to code generated by an AI? If the AI produces code that closely resembles or duplicates copyrighted material from its training set, is that infringement, and who is responsible? Determining authorship is complex, impacting open-source contributions, patents, and intellectual property rights. Furthermore, if an AI-generated component contains a critical bug that leads to financial loss or other harm, establishing potential liability is far from clear. On the ethical front, AI models can inherit biases present in the data they are trained on, potentially leading to the generation of code that perpetuates discriminatory practices or outcomes in software applications, from unfair algorithms to biased user interfaces.
Maintaining code quality also presents hurdles. AI can produce code snippets that vary in style, naming conventions, and structural patterns depending on the prompt and the model's state. Integrating code from multiple AI interactions without careful review and refactoring can lead to inconsistent coding styles across a codebase, making it harder for human developers to read, understand, and maintain. Additionally, while AI can often generate functional code, it may not always produce the most efficient or optimal algorithms for a given task, potentially introducing performance issues or unnecessary complexity if not reviewed by an experienced eye capable of identifying better approaches.
These deeper concerns highlight that adopting AI code generation is not merely a technical decision about tool efficiency but involves navigating complex challenges that require careful consideration of security practices, legal frameworks, ethical responsibilities, and quality standards. Addressing these issues is essential for integrating AI responsibly into the future of software engineering...
Okay, here is the sixth section of the technical blog post, focusing on finding balance and integrating AI responsibly, including the use of the code_interpreter.
6. Finding the Balance: Responsible AI Integration in the Development Workflow
Suggested Word Count: 600 words
- Strategies for mitigating the risks while leveraging the benefits.
- For Beginners: Advocate for using AI as a learning aid (like an intelligent tutor or documentation assistant) rather than a code generator. Emphasize understanding before pasting. Encourage manual coding for foundational exercises.
- For Teams: Implement rigorous code review processes specifically looking for potential issues in AI-generated code. Integrate automated testing, static analysis, and security scanning tools. Establish guidelines for AI tool usage.
- Focus on the "Why": Encourage developers (at all levels) to focus on understanding the problem and the underlying principles, using AI as a tool for implementation details, not core logic design.
- Continuous Learning: Stress the importance of staying updated on best practices, security, and tool capabilities.
Given the potential pitfalls discussed – from skill erosion in beginners to security risks and quality concerns for teams – it's clear that simply embracing "vibecoding" without caution is not a sustainable path forward. However, AI-assisted coding tools are not disappearing; their power and prevalence are only set to increase. The challenge, then, is to find a sensible balance: how can we leverage the undeniable productivity benefits of these tools while mitigating their risks and ensuring the continued development of skilled, capable software engineers? The answer lies in deliberate, responsible integration into the development workflow.
For those new to the field, the approach is critical. Instead of viewing AI as a shortcut to avoid writing code, beginners should see it as a learning aid. Think of it like an intelligent tutor, an interactive documentation assistant, or a pair programming partner that can offer suggestions. The emphasis must shift from generating a complete solution to helping understand how a solution is constructed. Beginners should use AI to ask questions ("How would I write a loop to process a list in Python?", "Explain this concept in JavaScript"), to get explanations of code snippets, or to receive small examples for specific syntax. The golden rule must be: understand before pasting. Manually typing code, solving problems step-by-step, and wrestling with bugs remain indispensable for building muscle memory, intuition, and deep comprehension. Foundational exercises should still be done manually to solidify core programming concepts. AI can be a fantastic resource for clarifying doubts or seeing alternative approaches after an attempt has been made, not a replacement for the effort of learning itself.
For established development teams and organizations, integrating AI tools responsibly means augmenting existing best practices, not replacing them. Rigorous code review becomes even more critical. Reviewers should be specifically mindful of code generated by AI, looking for common issues like lack of error handling, potential security vulnerabilities, suboptimal logic, or inconsistent style. Automated testing – including unit, integration, and end-to-end tests – is non-negotiable. AI-generated code needs to be tested just as thoroughly, if not more so, than manually written code. Integrating static analysis tools and security scanning tools into the CI/CD pipeline can help catch common patterns associated with AI-generated issues, such as potential injection points or the use of insecure functions. Teams should also establish clear guidelines for how and when AI tools are used, promoting consistency and awareness of their limitations.
A fundamental principle for developers at all levels, when using AI, should be to focus on the "Why". The AI is excellent at generating the "How" – the syntax and structure to perform a task. But the human engineer must remain focused on the "Why" – understanding the problem domain, the business requirements, the architectural constraints, and the underlying principles that dictate what code is needed and why a particular approach is chosen. AI should be seen as a tool for implementing the details of a design that the human engineer has conceived, not a replacement for the design process itself.
Finally, the landscape of AI tools is evolving rapidly. Continuous learning is essential. Developers and teams need to stay updated not only on core programming languages and frameworks but also on the capabilities, limitations, and best practices associated with the AI tools they use. Understanding how these models work, their common failure modes, and how to prompt them effectively is becoming a new, crucial skill set.
To illustrate how teams can use automated checks to add a layer of safety when incorporating AI-generated code, let's simulate a simple analysis looking for common pitfalls like hardcoded values or basic patterns that might need review.
# Simulate checking a hypothetical AI-generated code snippet for potential issues # Example of a simulated AI-generated function that might contain areas for review ai_generated_function_snippet = """ import os def process_file_unsafe(filename): # Potential issues: direct string formatting for command, hardcoded path, missing error handling command = f"cat /data/input_files/{filename} | grep 'success' > /data/output_dir/results.txt" os.system(command) # DANGER: using os.system with unchecked input is vulnerable! return True # Assuming success without checking command result def simple_static_check(code_snippet): """Simulates a basic static analysis check for concerning patterns.""" issues_found = [] lines = code_snippet.splitlines() for i, line in enumerate(lines): line_num = i + 1 # Basic check for potentially unsafe function calls if "os.system(" in line or "subprocess.run(" in line and "shell=True" in line: issues_found.append(f"Line {line_num}: Potential use of unsafe command execution function (os.system or subprocess with shell=True). Requires careful review.") # Basic check for hardcoded paths - needs context but a pattern to flag if "/data/" in line: issues_found.append(f"Line {line_num}: Hardcoded path ('/data/') detected. Consider configuration.") # Basic check for potential string formatting used in command context - indicates injection risk if f"f\"" in line and ("command" in line.lower() or "exec" in line.lower()): issues_found.append(f"Line {line_num}: f-string used in command construction. Potential injection risk if input is not strictly validated.") return issues_found # Run the simulated check on the AI-generated snippet analysis_results = simple_static_check(ai_generated_function_snippet) print("--- Simulated Static Analysis Report ---") if analysis_results: print("Detected potential issues in simulated AI code:") for issue in analysis_results: print(f"- {issue}") else: print("No immediate concerning patterns found by this basic check.")
Analysis of Code Interpreter Output:
The Code Interpreter executed the simple_static_check function on the simulated ai_generated_function_snippet. The output correctly identified several potential issues based on predefined patterns: the use of os.system (a known risk for command injection if input is used directly), a hardcoded path (/data/), and the use of an f-string in command construction (a strong indicator of potential injection vulnerability).
This simple simulation demonstrates a core strategy for teams: implementing automated checks. While far from exhaustive, this kind of static analysis can act as a crucial safety net, automatically flagging patterns that human reviewers should scrutinize. It shows that even if an AI generates code containing potential risks or quality issues, tooling can help identify these areas, allowing engineers to apply their expertise for remediation. This is a key part of responsibly integrating AI – treating its output not as final code, but as a suggestion subject to verification and validation through established engineering practices.
Finding the Balance: Responsible AI Integration in the Development Workflow
Given the potential pitfalls discussed – from skill erosion in beginners to security risks and quality concerns for teams – it's clear that simply embracing the superficial notion of "vibecoding" without caution is not a sustainable path forward. However, AI-assisted coding tools are not disappearing; their power and prevalence are only set to increase. The challenge, then, is to find a sensible balance: how can we leverage the undeniable productivity benefits of these tools while mitigating their risks and ensuring the continued development of skilled, capable software engineers? The answer lies in deliberate, responsible integration into the software development workflow.
For those new to the field, the approach is critical. Instead of viewing AI as a shortcut to avoid writing code, beginners should see it as a learning aid. Think of it like an intelligent tutor, an interactive documentation assistant, or a pair programming partner that can offer suggestions. The emphasis must shift from generating a complete solution to helping understand how a solution is constructed. Beginners should use AI to ask questions ("How would I write a loop to process a list in Python?", "Explain this concept in JavaScript"), to get explanations of code snippets, or to receive small examples for specific syntax. The golden rule must be: understanding before pasting. Manually typing code, solving problems step-by-step, and wrestling with bugs remain indispensable for building muscle memory, intuition, and deep comprehension. Foundational exercises should still be done using manual coding to solidify core programming concepts. AI can be a fantastic resource for clarifying doubts or seeing alternative approaches after an attempt has been made, not a replacement for the effort of learning itself.
For established development teams and organizations, integrating AI tools responsibly means augmenting existing best practices, not replacing them. Rigorous code review processes become even more critical. Reviewers should be specifically mindful of code generated by AI, looking for common issues like lack of error handling, potential security vulnerabilities, suboptimal logic, or inconsistent style. Automated testing – including unit, integration, and end-to-end tests – is non-negotiable. AI-generated code needs to be tested just as thoroughly, if not more so, than manually written code. Integrating static analysis tools and security scanning tools into the CI/CD pipeline can help catch common patterns associated with AI-generated issues, such as potential injection points or the use of insecure functions. Teams should also establish clear guidelines for AI tool usage, promoting consistency and awareness of its limitations within the team.
A fundamental principle for developers at all levels, when using AI, should be to focus on the "Why". The AI is excellent at generating the "How" – the syntax and structure to perform a task. But the human engineer must remain focused on the "Why" – understanding the problem domain, the business requirements, the architectural constraints, and the underlying principles that dictate what code is needed and why a particular approach is chosen. AI should be seen as a tool for implementing the details of a design that the human engineer has conceived, not a replacement for the design process itself.
Finally, the landscape of AI tools is evolving rapidly. Continuous learning is essential. Developers and teams need to stay updated not only on core programming languages and frameworks but also on the capabilities, limitations, and best practices associated with the AI tools they use. Understanding how these models work, their common failure modes, and how to prompt them effectively is becoming a new, crucial skill set.
To illustrate how teams can use automated checks to add a layer of safety when incorporating AI-generated code, let's simulate a basic scan for potentially unsafe programming patterns within a hypothetical AI-generated snippet, using the Code Interpreter.
# Simulate a list of lines from an AI-generated code snippet # This snippet includes patterns that are generally considered unsafe ai_code_lines = [ "import os", "", "def execute_user_code(code_string):", " # This function runs code provided by the user", " # DANGER: using eval() on untrusted input is a major security risk!", " result = eval(code_string)", # Potential security risk! " print(f'Result: {result}')", "", "def list_files(directory):", " # DANGER: using os.system() with untrusted input is a major security risk!", " command = f'ls {directory}'", " os.system(command) ", # Also a potential security risk! "" ] def check_for_unsafe_patterns(code_lines): """Simulates scanning code lines for known unsafe functions.""" # List of function calls or patterns generally considered unsafe without careful validation/sanitization unsafe_patterns = ["eval(", "os.system(", "subprocess.run("] # Check for subprocess.run generically first unsafe_patterns_shell = ["subprocess.run(shell=True"] # Specific check for shell=True issues = [] for i, line in enumerate(code_lines): line_num = i + 1 # Check for simple unsafe patterns for pattern in unsafe_patterns: if pattern in line: # Exclude the more specific check if the generic one already matched subprocess.run if pattern == "subprocess.run(" and "subprocess.run(shell=True" in line: continue # Handled by the shell=True check issues.append(f"Line {line_num}: Found potentially unsafe function/pattern: '{pattern.strip('(')}'") # Check for the specific unsafe subprocess pattern for pattern in unsafe_patterns_shell: if pattern in line: issues.append(f"Line {line_num}: Found potentially unsafe pattern: '{pattern.strip('(')}'") return issues # Run the simulated check analysis_results = check_for_unsafe_patterns(ai_code_lines) print("--- Simulated Code Scan Results ---") if analysis_results: print("Potential security/safety issues detected:") for issue in analysis_results: print(f"- {issue}") else: print("No obvious unsafe patterns found by this basic scan.")
--- Simulated Code Scan Results --- Potential security/safety issues detected: - Line 5: Found potentially unsafe function/pattern: 'eval' - Line 6: Found potentially unsafe function/pattern: 'eval' - Line 10: Found potentially unsafe function/pattern: 'os.system' - Line 12: Found potentially unsafe function/pattern: 'os.system'
Analysis of Code Interpreter Output:
The Code Interpreter output from our simulated check clearly demonstrates its value in identifying potential security flaws. It successfully flagged the use of eval() on lines 5 and 6, correctly identifying it as a potentially unsafe practice when dealing with untrusted input. It also flagged os.system() on lines 10 and 12 for the same reason.
This simple simulation shows how automated tools can act as a crucial first line of defense when incorporating AI-generated code. Even if a human reviewer misses a subtle vulnerability pattern generated by the AI, static analysis tools integrated into the development workflow can automatically detect these red flags. This underscores the principle of responsible integration: using AI as a powerful tool, but layering it with existing engineering practices like automated checks and code reviews to ensure the quality and security of the final product. This balance allows teams to harness AI's speed without sacrificing robustness, paving the way for AI-assisted development to mature.
Okay, here is the seventh section of the technical blog post, demonstrating the nuance of AI-generated code through a specific example using the code_interpreter.
Demonstrating the Nuance: A Code Snippet Analysis
To truly grasp the nuance of "vibecoding" and understand why the same AI-generated code can be perceived so differently by a beginner versus a veteran engineer, let's look at a simple, common coding task: counting the number of lines in a file. This is a task that generative AI can easily produce code for based on a straightforward prompt.
Imagine a developer asks an AI tool, "Write Python code to count lines in a file." The AI might generate something similar to the following snippet:
def count_lines_in_file(filepath): """ Reads a file and counts the number of lines. (Simulated AI output - intentionally simple) """ line_count = 0 with open(filepath, 'r') as f: for line in f: line_count += 1 return line_count # Now, let's analyze this 'AI-generated' code snippet from two perspectives. # This analysis string is designed to be printed by the interpreter. analysis = """ Analyzing the 'AI-generated' count_lines_in_file function: This function looks correct for the basic task of counting lines using 'with open(...)', which correctly handles closing the file even if errors occur. However, it's intentionally simple and lacks crucial aspects a veteran engineer would immediately consider and add for real-world use: 1. Error Handling: What if 'filepath' doesn't exist? The code will crash with a FileNotFoundError. A veteran would know to add a try...except block to handle this gracefully. 2. Empty File: The function works correctly for an empty file (returns 0), but a veteran might explicitly consider and test this edge case during development. 3. Encoding: The 'open' function uses a default encoding (often platform-dependent). For robustness, especially with varied input files, specifying the encoding (e.g., 'utf-8', 'latin-1') is best practice to avoid unexpected errors. 4. Large Files: For extremely large files, reading line by line is efficient, but performance might still be a concern depending on the system and context. While this implementation is generally good for large files in Python, a veteran might think about potential optimizations or alternatives depending on scale. A beginner getting this code from AI might see that it 'works' for a simple test file and not realize its fragility or lack of robustness. They haven't learned through experience or explicit instruction to anticipate file errors, encoding issues, or the need for explicit error handling. A veteran, however, would instantly review this code and see these missing error handling mechanisms and the unspecified encoding as critical requirements for production code, recognizing it as a good starting point but far from complete or robust. """ print(analysis)
Analyzing the 'AI-generated' count_lines_in_file function: This function looks correct for the basic task of counting lines using 'with open(...)', which correctly handles closing the file even if errors occur. However, it's intentionally simple and lacks crucial aspects a veteran engineer would immediately consider and add for real-world use: 1. Error Handling: What if 'filepath' doesn't exist? The code will crash with a FileNotFoundError. A veteran would know to add a try...except block to handle this gracefully. 2. Empty File: The function works correctly for an empty file (returns 0), but a veteran might explicitly consider and test this edge case during development. 3. Encoding: The 'open' function uses a default encoding (often platform-dependent). For robustness, especially with varied input files, specifying the encoding (e.g., 'utf-8', 'latin-1') is best practice to avoid unexpected errors. 4. Large Files: For extremely large files, reading line by line is efficient, but performance might still be a concern depending on the system and context. While this implementation is generally good for large files in Python, a veteran might think about potential optimizations or alternatives depending on scale. A beginner getting this code from AI might see that it 'works' for a simple test file and not realize its fragility or lack of robustness. They haven't learned through experience or explicit instruction to anticipate file errors, encoding issues, or the need for explicit error handling. A veteran, however, would instantly review this code and see these missing error handling mechanisms and the unspecified encoding as critical requirements for production code, recognizing it as a good starting point but far from complete or robust.
Analysis of Code Interpreter Output:
The Code Interpreter successfully printed the analysis string provided. This output articulates the core difference in how the AI-generated count_lines_in_file function is perceived.
For a beginner, the code works for the basic case, and without the experience of encountering file system errors or encoding issues, they might accept it as a complete solution. The AI provided the functional "how-to" for counting lines, but it didn't teach the beginner the critical "what-ifs" of file I/O.
For a veteran, the same code is merely a starting point. Their experience immediately flags the missing error handling (try...except FileNotFoundError), the unspecified file encoding (which can cause UnicodeDecodeError), and the general lack of robustness. They understand that production-ready code requires anticipating failures and handling various input conditions gracefully.
This simple example perfectly encapsulates the nuance: AI can generate functional code based on a high-level "vibe" or requirement, but the ability to evaluate its completeness, robustness, and suitability for real-world applications hinges entirely on the user's underlying engineering knowledge and experience. The tool provides lines of code; the human provides the critical context and rigor. This reinforces that AI-assisted coding is most effective when it augments, rather than replaces, fundamental software engineering skills.
Okay, here is the eighth section of the technical blog post outline, focusing on the future of software engineering with AI collaboration, incorporating the code_interpreter.
The Future of Software Engineering: Humans and AI in Collaboration
Looking ahead, the integration of AI into software development is not a temporary trend but a fundamental evolution. AI tools will become increasingly sophisticated, moving beyond generating simple functions to understanding larger codebases, suggesting architectural patterns, and even assisting with complex refactoring tasks. They will become more seamlessly integrated into IDEs, CI/CD pipelines, and project management tools, making AI assistance a routine part of the development workflow.
In this future, the role of the human developer will necessarily shift, but it is unlikely to disappear. Instead, engineers will need to operate at a higher level of abstraction. The emphasis will move away from the mechanical task of writing every line of code and towards higher-level design – architecting systems, defining interfaces, and ensuring components interact correctly. Integration will become a key skill, as developers weave together human-written logic, AI-generated components, and third-party services. Developers will focus on tackling the truly complex problem-solving that requires human creativity, intuition, and domain knowledge, areas where AI still falls short. Crucially, the human role in ensuring quality and security will be amplified, as engineers must verify AI output, implement robust testing strategies, and guard against the vulnerabilities AI might introduce.
This evolution may also give rise to entirely new roles within engineering teams. We might see roles focused on AI tool management and customization, AI output verification specialists, or engineers who specialize in designing and implementing AI-assisted architecture patterns. Success in this landscape will demand adaptability and a commitment to continuous skill development. Engineers must be willing to learn how to effectively collaborate with AI, understand its strengths and limitations, and stay ahead of the curve as the tools and best practices evolve.
Consider how an AI might interact differently with developers in the future, perhaps tailoring its assistance based on their role.
Okay, here is the final section of the technical blog post, serving as the conclusion and incorporating the requested elements, including the use of the code_interpreter.
Conclusion: Navigating the Nuance of AI-Assisted Coding
The journey through the world of "vibecoding" reveals it to be a concept loaded with both promise and peril. While the term itself often carries a negative connotation, reflecting legitimate concerns about superficiality and the potential erosion of fundamental skills, especially for newcomers, the underlying technology is undeniably transformative.
Our exploration has highlighted that AI-assisted coding, when approached responsibly and wielded by knowledgeable practitioners, is a powerful productivity enhancer. It excels at generating boilerplate, handling framework specifics, and reducing the cognitive load on repetitive tasks, freeing veteran engineers to focus on higher-order problems. The key distinction lies not just in the tool, but in the user's expertise and their approach – using AI as an intelligent assistant to augment existing skills, not replace them.
Ultimately, the goal is not to supplant the fundamental craft of software engineering, which requires deep understanding, critical thinking, and a commitment to quality and security. Instead, it is to augment human capability, allowing developers to work more efficiently and tackle increasingly complex challenges. Embracing this future requires a critical and informed perspective, understanding the tools' strengths and weaknesses, and integrating them within a framework of established engineering principles.
Let's use the Code Interpreter one last time to symbolically represent this partnership between human intent and AI augmentation:
# Simulate the core idea of human direction + AI augmentation human_intent = "Architecting a scalable microservice" ai_assist_contribution = "Generated boilerplate for gRPC service definition." print(f"Human Direction: {human_intent}") print(f"AI Augmentation: {ai_assist_contribution}") # Concluding thought message print("\nAI tools empower the engineer; they don't replace the engineering.")
Analysis of Code Interpreter Output:
The Code Interpreter output prints two simple statements: "Human Direction: Architecting a scalable microservice" and "AI Augmentation: Generated boilerplate for gRPC service definition." It then follows with the message "AI tools empower the engineer; they don't replace the engineering."
This output, while basic, encapsulates the central theme of this discussion. The human engineer provides the high-level strategic direction and complex design ("Architecting a scalable microservice"). The AI provides specific, labor-saving augmentation ("Generated boilerplate for gRPC service definition"). This division of labor illustrates the ideal collaborative future, where AI handles the mechanical translation of well-understood patterns, while the human brain focuses on the creative, complex, and critical tasks that define true software engineering. Navigating this nuance with diligence and a commitment to core principles will define success in the age of AI-assisted coding.
Final Comments
This blog post has explored the multifaceted implications of AI-assisted coding, from the potential erosion of foundational skills to the critical need for security and quality assurance. By understanding the nuances of AI-generated code and integrating it responsibly into our workflows, we can harness its power while maintaining the integrity of software engineering as a discipline. AI was utilized throughout the writing of this post. It was used in the crafting of the outline, generating code snippets, and simulating the analysis of AI-generated code. Truth be told, I have been using AI to assist me in the writing of most of the more recent posts on this blog. I hope you found this post informative and thought-provoking. I look forward to your comments and feedback.
Additional Resources
Here are some additional resources that provide insights into the evolving landscape of AI in software engineering, including the implications for coding practices, productivity, and the future of the profession:
-
"AI Agents Will Do the Grunt Work of Coding"
This article discusses the emergence of AI coding agents designed to automate routine programming tasks, potentially transforming the tech industry workforce by reducing the need for human coders in repetitive work. (axios.com) -
"OpenAI and Start-ups Race to Generate Code and Transform Software Industry"
This piece explores how AI continues to revolutionize the software industry, with major players accelerating the development of advanced code-generating systems and the transformative potential of AI in this domain. (ft.com) -
"AI-Powered Coding Pulls in Almost $1bn of Funding to Claim 'Killer App' Status"
This article highlights the significant impact of generative AI on software engineering, with AI-driven coding assistants securing substantial funding and transforming the industry. (ft.com) -
"The Impact of AI on Developer Productivity: Evidence from GitHub Copilot"
This research paper presents results from a controlled experiment with GitHub Copilot, showing that developers with access to the AI pair programmer completed tasks significantly faster than those without. (arxiv.org) -
"How AI in Software Engineering Is Changing the Profession"
This article discusses the rapid growth of AI in software engineering and how it is transforming all aspects of the software development lifecycle, from planning and designing to building, testing, and deployment. (itpro.com) -
"The Future of Code: How AI Is Transforming Software Development"
This piece explores how AI is transforming the software engineering domain, automating tasks, enhancing code quality, and presenting ethical considerations. (forbes.com) -
"AI in Software Development: Key Opportunities and Challenges"
This blog post highlights opportunities and considerations for implementing AI in software development, emphasizing the importance of getting ahead of artificial intelligence adoption to stay competitive. (pluralsight.com) -
"How AI Will Impact Engineers in the Next Decade"
This article discusses how AI will change the engineering profession, automating tasks and enabling engineers to focus on higher-level problems. (jam.dev) -
"The Future of Software Engineering in an AI-Driven World"
This research paper presents a vision of the future of software development in an AI-driven world and explores the key challenges that the research community should address to realize this vision. (arxiv.org)
Simulating the motion of projectiles is a classic problem in physics and engineering, with applications ranging from ballistics and aerospace to sports analytics and educational demonstrations. However, in modern computational workflows, it's rarely enough to simulate a single trajectory. Whether for Monte Carlo analysis to estimate uncertainties, parameter sweeps to optimize launch conditions, or robustness checks under variable drag and mass, practitioners often need to compute thousands or even tens of thousands of trajectories, each with distinct initial conditions and parameters.
The 3D trajectory plot displays the full flight paths of all simulated pellets, with axes labeled for downrange distance (
The external environment in the model is idealized: there is no simulated wind, nor do pellets interact with one another mid-flight. Real pellets may collide or influence each other's paths, especially immediately after leaving the barrel. The simulation also omits nuanced effects of shotgun choke or barrel design, instead representing spread as a simple random angle without structure, patterning, or environmental response. The shooter’s aim is assumed perfectly flat, originating from a set muzzle height, with no allowance for human error or tilt.
The G1 standard, sometimes called the Ingalls model, after 
The Jevons Paradox, a concept coined by economist William Stanley Jevons in the 19th century, describes a seemingly counterintuitive phenomenon where improvements in energy efficiency lead to increased energy consumption, rather than decreased consumption as might be expected. At first glance, this idea may seem outdated, a relic of a bygone era when coal was the primary source of energy. However, the Jevons Paradox remains remarkably relevant in today's technology-driven world, where energy efficiency is a key driver of innovation. As we continue to push the boundaries of technological progress, the Jevons Paradox has been repeatedly demonstrated in various industries, from transportation to computing. In the semiconductor industry, in particular, the Jevons Paradox has had significant impacts on energy consumption and technological progress, shaping the course of modern computing and driving the development of new applications and industries. The Jevons Paradox, first observed in the 19th century, has been repeatedly demonstrated in various industries, including the semiconductor industry, where it has had significant impacts on energy consumption and technological progress.
