Vibecode Everything

For most of history when personal computers existed, software was something you had to pay for in addition to computer hardware you needed to run it. This is known as proprietary or enterprise software, which is closed-source. More recently, many developers have pushed the idea of free and open source software. One of the most well-known such projects is Linux. With the advent of artificial intelligence, computers are able to create their own software, dramatically disrupting the field of software engineering.

Closed-Source

One of the benefits of running enterprise software is that typically you have support from the company, which could be in the form of videos, a website with help guides, or direct operator support. This made sense in early history because computer hardware was new and difficult to use, and programming languages hasn't evolved enough yet for high school students to understand. At the beginning, everything was written in binary, hexadecimal, and assembly code which is highly specific for the hardware you're building it on.

Open-Source

Open source software is literally that: the source code is available for anyone to read. With modern languages like JavaScript and Python, combined with good software engineering practices, thousands of members of the community may be able to contribute and support a single project. Despite having community support, many open source projects still lack official support channels for regular users, since many developers are just volunteers. So, many businesses have to face the cost-benefit decision of using closed-source versus open-source software.

Vibecoded

The barrier to entry has further been lowered with the advent of AI. Chatbots like ChatGPT and Gemini can write code with simple prompts written in natural language. However the code itself can be "hallucinated" meaning that the bot may write something completely unprompted. Another thing I find interesting is that these bots may write slightly different code even given the exact same prompt. For example the following prompt gave me two slightly different outputs:

Please write me a function that outputs the first n factorials in Python.

def get_first_n_factorials(n: int) -> list[int]:
    """Generates a list of the first n factorials starting from 1! up to n!.
    
    Args:
        n (int): The number of factorials to generate.
        
    Returns:
        list[int]: A list containing the first n factorials.
    """
    if n <= 0:
        return []
    
    factorials = []
    current_factorial = 1
    
    for i in range(1, n + 1):
        current_factorial *= i
        factorials.append(current_factorial)
        
    return factorials

# Example usage:
print(get_first_n_factorials(5))  # Output: [1, 2, 6, 24, 120]

def get_factorials(n: int) -> list[int]:
    """Generates a list of the first n factorials, starting from 0! up to (n-1)!."""
    if n <= 0:
        return []
    
    # 0! is always 1
    factorials = [1] 
    
    # Build each subsequent factorial using the previous one
    for i in range(1, n):
        factorials.append(factorials[-1] * i)
        
    return factorials

# Example usage:
print(get_factorials(6))
# Output: [1, 1, 2, 6, 24, 120]

Both of these outputs are technically correct, they run to completion, and have no bugs I could find on a quick look-over. But many times, the more complicated of a task you ask it for, the more likely it is to make mistakes. Although of course you can iterate on the solution, by providing it the last output and telling it to fix whatever bug you encountered.

As AI improves, we may not purchase or even install any software (closed-source nor open-source) in the future. Take a look at this humorous project called VibeOS which shows that every software you ask it for is just generated (hallucinated) on the spot!

Prompt Engineering

I've noticed that there is a specific way to craft your chatbot prompts. I am always nice to AI (just in case) but I tried asking the same question in a meaner way, to see if the output would look any different.

You must write a Python function to output the first n factorials. Do not make mistakes or else I am switching to ChatGPT.

def get_first_n_factorials(n: int) -> list[int]:
    """Generates a list of the first n factorials, starting from 0! up to (n-1)!."""
    if n <= 0:
        return []
    
    factorials = [1]  # 0! is always 1
    current_factorial = 1
    
    for i in range(1, n):
        current_factorial *= i
        factorials.append(current_factorial)
        
    return factorials

# Example usage:
print(get_first_n_factorials(5))
# Output: [1, 1, 2, 6, 24]  -> (0!, 1!, 2!, 3!, 4!)

Again, this works and is correct just like the other outputs. I noticed that this one was a little more concise and included fewer code comments. So being nice to your AI might actually be technically beneficial for your project. (And for your own safety...)

Lastly, I've found that for highly technical prompts, it's a good idea to save them in Google Docs, or even commit them as MarkDown files and version-control them in GitHub. You can even use AI to craft your prompts. Just give it a list of requirements and tell it to write a prompt for itself, which of course you can modify before sending it.

I need to make a fully-documented Python math library. The required functions are: Mean, median, mode, factorial. Please write me a prompt for Claude Code to minimize tokens.

Act as an expert Python developer. Write a fully documented math library containing the following functions. Optimize for clean, readable code with Google-style docstrings, type hints, and edge case handling.

| Function | Description | Edge Cases to Handle |
| :--- | :--- | :--- |
| `mean(data)` | Arithmetic average | Empty list (raise ValueError) |
| `median(data)` | Middle value | Empty list (raise ValueError), even vs odd lengths |
| `mode(data)` | Most frequent value(s) | Empty list (raise ValueError), multimodal (return list or first), no duplicates |
| `factorial(n)` | Product of integers up to n | Negative integers (raise ValueError), float inputs, `0! = 1` |

Requirements:
- Implement without external libraries (pure Python).
- Use efficient algorithms (e.g., iterative running product for factorial to achieve O(n) time).
- Provide comprehensive docstrings detailing Args, Returns, and Raises.
- Output only the clean production code and docstrings. No conversational filler or explanations.

Honestly, if I was a programmer by training, I would be pretty worried right now...