AI & Programming: The Illiterate Programmer Generation

The integration of Artificial Intelligence (AI) into software development is rapidly changing the landscape for programmers. While AI tools like ChatGPT and GitHub Copilot offer significant advantages, there's a growing debate about whether they're creating a generation of 'illiterate' programmers who rely too heavily on AI and lose fundamental coding skills. This article explores this complex issue, examining the potential pitfalls of over-reliance on AI, the importance of maintaining core coding abilities, and the emerging trend of offline AI models as a way to retain control and independence in the age of AI.

Is AI Creating a Generation of Illiterate Programmers?

The integration of AI into programming is undeniably accelerating. AI Tools are automating tasks that once required significant manual effort, such as code generation, debugging, and testing. This can lead to increased productivity and faster development cycles. However, some experts argue that this reliance on AI may be creating a generation of programmers who lack a deep understanding of the underlying code and algorithms. They become dependent on AI to solve problems, rather than developing their own problem-solving skills.

The Core Argument: The argument centers around the idea that if programmers become too reliant on AI, they may lose the ability to code independently, troubleshoot effectively, and understand the nuances of software architecture. This can lead to a decline in overall programming competency and innovation. The fear is that programmers will become mere 'Prompt engineers,' guiding AI to generate code without truly comprehending its function.

The Counter-Argument: Conversely, proponents of AI in coding argue that it's a tool that empowers programmers to focus on higher-level tasks and solve more complex problems. AI can handle the tedious and repetitive aspects of coding, freeing up programmers to concentrate on design, architecture, and innovation. It's a question of balance and responsible use.

The Allure and Peril of AI Autocompletion Tools

AI autocompletion tools, such as GitHub Copilot and AI-powered IDEs, have revolutionized the coding experience. These tools use machine learning to predict and suggest code snippets as you type, accelerating the coding process. While incredibly convenient, they also present a potential risk: over-reliance. When a programmer consistently accepts AI-generated suggestions without fully understanding them, they may gradually lose their ability to write code from scratch or debug effectively. It’s similar to using a calculator for simple math problems – eventually, you might forget how to do the calculations yourself. The key is to use these tools judiciously and maintain a strong foundation in core programming principles.

AI autocompletion is becoming increasingly common. Programmers are now using AI tools to manage error messages, to help them learn new programming languages, and to increase efficiency. This trend raises questions about how these AI services might reshape the future of software development.

• GitHub Copilot: The pair programmer that gives suggestions and auto-completes code.

• Cursor: AI-first code editor to help build, debug, and understand code faster.

  It is up to the programmer to decide how and when to use such tools to complete their coding goals. The ultimate hope is that AI provides assistance in completing the goals, not total and complete automation.

Taking Control of Your AI: The Rise of Local LLMs

One of the key concerns surrounding AI-powered coding tools is the reliance on centralized, cloud-based services. If the service goes down, as happened recently with ChatGPT, programmers can find themselves unable to code efficiently or even at all.

This vulnerability has fueled the growing interest in offline AI models, also known as local Large Language Models (LLMs).

What are Offline AI Models? Offline AI models are AI models that run directly on your own hardware, such as your laptop, desktop, or a dedicated server. This eliminates the need for an internet connection and provides greater control over your data and code. It also safeguards against outages and ensures that your programming environment remains functional even when external AI services are unavailable.

The Benefits of Offline AI:

• Independence: Not reliant on external services.
• Control: Ability to fine-tune the models.
• Privacy: Protecting your code and data.

Combating Illiteracy with Independence: The Necessity of Local Models

The speaker emphasizes the importance of having your own offline models. He believes that this is the only way to combat the generation of illiterate programmers

. Relying on bigger companies will only make individuals incapable of running their own systems. The goal of many larger corporations is to charge monthly fees for services that programmers could, in theory, achieve themselves through independence and competence.

Imagine a scenario where a programmer relies on a chain of AI services, each dependent on the other, all charging monthly fees. The speaker fears that AI will just be ChatGPT or Anthropic, just with a whole lot of markup. This is why it's critical to have offline, local large language models. By having a local AI model, developers can prevent being beholden to these larger companies.

Furthermore, the speaker states that he has already bought thousands of dollars in Mac Minis and is planning to buy a Raspberry Pi to support a move towards local AI .

The Tech Needed to Run Offline AI Models

To set up and run offline AI models, developers should consider investing in the following tech:

• Mac Minis: A small form factor desktop computer with Apple silicon.
• Raspberry Pi: A single-board computer used for various projects including self-hosting AI models.
• GPUs (Graphics Processing Units): Needed for training and running AI models. Consider purchasing a Tinygrad box to maximize GPU performance.

Running Offline AI Models on the Mac: Here's a step-by-step guide to running your models locally, which is particularly relevant for Mac users:

1. Install Homebrew: Homebrew is a package manager for macOS, essential for installing many open-source tools. You can install it by pasting the following command into your terminal:

   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. Install Python: Most AI and machine learning tools are built using Python. Install it via Homebrew:

   brew install python

3. Set Up a Virtual Environment: It's good practice to create a virtual environment to manage dependencies for your project:

   python3 -m venv .venv
   source .venv/bin/activate

4. Install PyTorch: PyTorch is a popular open-source machine learning framework:

   pip install torch torchvision torchaudio

5. Download the AI Model: Find the specific AI model you want to run offline and download the necessary files. This could be a model for Image Recognition, language processing, or another task.

6. Load the Model: Using Python and PyTorch, load the model into your application or script:

   import torch
   
   model = torch.load('path/to/your/model.pth')
   model.eval()

7. Run the Model: Provide the necessary inputs to the model and run it:

   input_data = torch.randn(1, 3, 224, 224)  # Example input for an image recognition model
   output = model(input_data)
   print(output)

   By following these steps and using the right technology, programmers can make their own AI tools and become independent from large AI corporations.

Strategies for Programmers

Here's how to avoid becoming overly dependent on AI in coding:

• Master the Fundamentals: Invest time in learning core programming concepts, algorithms, and data structures.
• Code from Scratch: Regularly practice writing code without AI assistance to maintain your skills.
• Understand AI Suggestions: Don't just accept AI-generated code. Take the time to understand what the code does and why it works.
• Debug Manually: Practice debugging code without relying solely on AI tools.
• Participate in Code Reviews: Participate in code reviews to learn from other programmers and gain insights into different coding styles and approaches.

Choosing When to Use AI in Coding

AI is not meant to be a crutch, it is meant to be a tool. AI should be used when a programmer needs help but knows that they can still accomplish a specific coding task without help. AI should not be used because a programmer cannot code on their own. Consider the following tips:

• Use AI for Repetitive Tasks: Utilize AI to automate repetitive tasks.
• Don’t Use AI for Entire Projects: Do not rely on the AI to produce the entire project, you must still work in tandem to reach a finished result.
• Take Breaks: AI helps increase productivity, so allow yourself more breaks during the day.