I'm apparently doing it wrong.
According to Andrej Karpathy,
There's a new kind of coding I call 'vibe coding', where you fully give in to the vibes, embrace exponentials, and forget that the code even exists. You just talk to the AI and the app appears.
That sounds way too California to me, too much prompt-and-pray. I'm not going to kick back, grab a kombucha, and tell my model to Create me an SaaS app, bro. What I do is more akin to Dialectical Software Engineering, but that rolls trippingly off the tongue like peanut butter, so I'm going to call it East Coast Vibing.
I work with two LLMs to vibe code my application. I start with Gemini as my high-level sparring partner LLM. Its role is to be the general contractor for the project. I present an architecture to it and it takes an adversarial approach and challenges my ideas. It asks questions about the requirements and specific design decisions. It pokes holes in my design and makes sure that I have considered all of the relevant factors and edge cases. It will also consider the broader context of the project, including design patterns, user requirements, and long-term maintainability.
I'll spend a couple of hours with general contractor arguing design points until we are both satisfied. Only then do I move to the step of actual code generation using a different LLM, GitHub Copilot, which is the code monkey. The role of the code monkey is to write the actual application code. Its context isn't the broad architectural design I hammered out with the general contractor, but specific and detailed knowledge of the codebase, the design patterns, and the style of the code.
I meta-prompt the general contractor to generate a detailed prompt for the code monkey to carry out. The prompt generated for the code monkey is quite detailed and specific. It includes the requirements, the design decisions, and the specific code that needs to be written. A typical meta-prompt would be something like this:
Provide an OpenAPI discovery binding for servers who want to discover our API.
This is naturally far too vague a prompt for an LLM to directly carry out, but the general contractor has the context of the project and arguments about the design decisions that we just hammered out, so it can generate a detailed prompt for the code monkey to carry out. It generates a prompt that looks something like this:
I am adding an OpenAPI 3.0 discovery document to a Common Lisp Hunchentoot
API. Act as an expert Common Lisp developer.
Write a Lisp file (or function) that defines and serves a static OpenAPI spec.
**1. The OpenAPI Specification (YAML or JSON):**
Define a global variable (e.g., `*openapi-spec*`) containing the raw OpenAPI 3.0 text. The spec must define:
* **Info:** Title: "JRM Code Project API", Version: "1.0.0".
* **Servers:** URL: `https://jrm-code-project.com`.
* **Paths:**
* `POST /api/v1/auth/token`:
* Description: "Exchange an API key for a short-lived JWT."
* Request Body (required, application/json): `email` (string) and `api_key` (string).
* Responses:
* `200`: Success. Returns `access_token` (string), `expires_in` (integer), and `token_type` (string).
* `400`: Bad Request.
* `401`: Unauthorized (Invalid credentials).
* `429`: Too Many Requests.
* **Components/SecuritySchemes:**
* Define a `BearerAuth` scheme (type: `http`, scheme: `bearer`, bearerFormat: `JWT`).
* **Security:** Apply `BearerAuth` globally (optional, but good for future endpoints).
**2. The Hunchentoot Route:**
Write a Hunchentoot handler (e.g., `define-easy-handler`) for `GET /openapi.yaml` (or `.json` depending on how you formatted the string).
* It should set the appropriate `content-type` (`application/yaml` or `application/json`).
* It should return the contents of `*openapi-spec*`.
* Ensure this route is *not* protected by the JWT or restrictive rate limiting, as it must be publicly discoverable by machines.
Write clean, idiomatic Lisp. Just embed the spec as a string literal to keep
dependencies minimal; we don't need a heavy YAML parsing library just to serve a
static document.
This detailed prompt is then handed to Copilot, which writes the actual Common Lisp code that implements the specified endpoints and updates the OpenAPI specification. Copilot focuses on extending the existing codebase and ensuring that the new code adheres to the existing architecture and coding standards. It does not need to worry about the broader context of the project, as that is the responsibility of the general contractor. The prompt given to the `code monkey' is detailed and specific enough that it can write the code without hallucinations and test the code it has written to ensure that it meets the requirements.
You can get away with a few rounds of this back-and-forth with the general contractor and code monkey but technical debt will accumulate quickly. The code monkey will write working code, but it will take shortcuts and make decisions that are expedient in the short term but will cause problems in the long term. This is the point where we need to go in and refactor the code to make it more maintainable and extensible.
We go directly to the code monkey and prompt it to analyze the code and identify the technical debt. We prompt the LLM to rank the technical debt in order of severity and impact and write it to a file. Then we iterate with the simple prompt of Select the most important element of technical debt and address it. We burn down the P0 and P1 technical debt and address a number of the P2 items. Attempting to address all of the P2 items tends to lead to code churn and diminishing returns, but the P0 and P1 items are absolutely worth addressing. Every few rounds of feature development, we return to addressing the technical debt. This is important to keep the codebase from becoming a tangled mess of spaghetti code.
Left to its own devices, the LLM will write imperative, procedural code. That is because the bulk of the code it has been trained on is imperative, procedural code. This kind of code is easy to write, but it is hard to maintain and extend. State tends to creep into the code base and the LLM will find it difficult to reason about the code because it has to keep track of the state of the system across multiple functions and modules.
The solution is to prompt the LLM to write functional code. Functional code is easier to reason about because it is stateless and the output of a function depends only on its input. With functional code, the LLM can reason locally and does not need to keep track of implicit time. If the code is largely written in a functional style, the LLM will find it easier to continue to extend the code in a functional style, but it will occasionally slip back into imperative, procedural code. When that happens, we prompt the LLM to refactor the code to be more functional.
Early on in the project, we prompt the LLM to do a full functional refactoring of the codebase. This is a big job and takes multiple steps. If the code fundamentally models side effects, then it is difficult to refactor it to be fully functional. If this is the case, we prompt the LLM to move the side effects to the edges of the codebase and keep the core of the codebase functional through use of functional/reactive programming and monadic programming techniques.
Pure functional code is easier to test and debug because each function can be written and tested in isolation. The LLM can limit the scope of the code it is writing to a single function and at a time. It can reason about the function and its inputs and outputs without having to reason about the state of the code that calls the function.
Taking a disciplined approach to software development will prevent the LLM from writing fragile code that collapses under the weight of its own complexity. It will allow the LLM to write code that is maintainable and extensible.
East Coast Vibing is a disciplined approach to software development that involves these steps:
No doubt people will argue that this is the wrong way to do things and that I have completely misunderstood what Karpathy meant by vibe coding. Perhaps I have, but I have found it an effective way to build software. If you want to kick back with a kombucha and "give in to the exponentials" while the AI hallucinates a brittle Jenga tower, go right ahead. But I suggest you grab a strong black coffee and try the East Coast Vibing approach and engineer a solution.