VibeKit: Programming by Vibes, Not Specs

I was in a meeting last week when my colleague Klemen dropped something he thought was truly absurd in our work Slack: "I've got a new proposal that's gonna blow your mind: VibeKit. It's the ultimate library—no rules, no limits, just vibes. [..] you can call any function you dream up, and it just works. [...] No need to define multiply or parse_web_page - VibeKit feels what you mean and delivers."

Everyone laughed and moved on. Everyone except me.

Because here's the thing about terrible ideas in software: sometimes they're just terrible enough to become brilliant.¹

Introducing VibeKit

Last night in a fit of insomnia (brought you to by the letter Q, the number 2.71828, and a 6 PM "nap" that ended at 11 PM) I'm releasing VibeKit, a Python library that lets you call literally any function you can imagine without ever having to implement it. Yes, you read that correctly, and yes, it is a spectacularly bad idea.

from vibekit import VibeKit

vibe = VibeKit(api_key="sk-proj-8675309urmom")

# This function definition doesn't exist in the codebase
result = vibe.calculate_hypotenuse_of_right_triangle(3, 4)
print(result)  # 5, unless the LLM _feels_ something else

No function definitions. No imports. No documentation reading. Just pure, unbridled vibes.

How It Works (or: What In The World Have I Done?)

VibeKit intercepts any method call on its client object and sends it to an LLM with instructions that essentially say "figure out what this function should do and give me the result." The LLM interprets the function name and parameters, executes the implied logic, and returns the result.

• Is this horribly inefficient? Absolutely.
• Is it completely absurd? Without question.
• Does it actually work? More often than I would have imagined.

The Birth of Vibe-Based Programming

In traditional programming, you need:

1. Clear specifications
2. Precise function definitions
3. Explicit logic

In vibe-based programming, you need:

1. A function name that hopefully conveys your intent
2. An internet connection
3. A complete disregard for computational efficiency and API spend

I've been testing this with increasingly ridiculous function names, and the results are both hilarious and impressive:

vibe.tell_me_a_joke_about_python_programmers_that_my_grandmother_would_understand()

vibe.calculate_how_many_rubber_ducks_would_fit_in_the_grand_canyon()

vibe.explain_quantum_mechanics_using_only_cereal_metaphors()

Each of these returns exactly what you'd expect, despite none of these functions existing in any programming library ever created.

Actually, here's what they return!

{
    "joke": "Why do Python programmers prefer dark mode? Because light attracts bugs!"
}

{
    "rubber_ducks_fit_in_grand_canyon": 2000000000
}

{
    "explanation": "Imagine the universe as a giant bowl of cereal. Each type of cereal represents a different particle, like electrons and photons. Just like cereal pieces can be in different shapes and sizes, particles have different properties. When you pour milk into the bowl, it represents the wave function, which spreads out and mixes everything together. Just as you can't predict exactly where each piece of cereal will float, in quantum mechanics, you can't pinpoint the exact location of a particle until you look at it. When you take a spoonful of cereal, you're making a measurement, collapsing the wave function and determining the state of the particles, just like observing a quantum system. And sometimes, you might find that two pieces of cereal are stuck together, similar to quantum entanglement, where particles become linked and affect each other, no matter how far apart they are. So, in the end, quantum mechanics is like enjoying a bowl of cereal where everything is interconnected and uncertain until you take a closer look."
}

Why This Is Actually (Maybe) Useful

Beyond the obvious humor, there's a weird practicality to this approach for certain scenarios:

1. Rapid prototyping: When you're sketching out an application and don't want to get bogged down implementing every little helper function.

2. Domain-specific problems: When you need to solve a one-off problem in a domain you're not familiar with with blatant disregard for the correctness of the response, but find that the direction of the response is important. (As is often the case with LLMs when you don't ask how many r's are in strawberry),

3. "Good enough" computing: When you need an approximate solution and don't care about performance or how much money you spend to get it.

It's programming by intention rather than implementation. You express what you want, not how to do it.

The Future of Not Defining Things

Will VibeKit replace traditional programming? Obviously not. It's inefficient, expensive (those API calls add up), and introduces a level of unpredictability that would make any serious software engineer break out in hives.

But it does highlight something interesting about where programming might be headed. As models get better and computation gets cheaper, the line between natural language and programming language continues to blur.

For now, though, VibeKit remains a ridiculous experiment that somehow works—a testament to taking jokes too far and the strange magic that happens when you do.

---

If you want to try it out yourself, installation is as straightforward as:

pip install vibekit

Just remember to set your OpenAI or Anthropic API key as an environment variable first, otherwise you'll be sending vibes to nowhere.²