Vibe Coding: The next layer of Abstraction or Just Better Scaffolding?

“Vibe coding” has become one of those love-it-or-hate-it terms. Some developers hear it and assume it is junior devs letting ChatGPT write spaghetti code for them. But that is the shallow version. Underneath the memes, there is a serious shift in how we translate business intent into running systems

In the following post, I will argue that vibe coding is not about being lazy. It is about moving the design work up into natural language and letting AI agents scaffold the boring parts: data contracts, API endpoints, and service orchestration wiring.

What is Vibe Coding?

Andrej Karpathy (co-founder of OpenAI and former AI leader at Tesla) in Feb 2025 tweeted about “Vibe coding” – A new paradigm where you describe what you want in plain language and let an LLM generate most of the code
The key ideas:

• You start from a natural language description of the feature
• An LLM generates code based on that description, often across multiple files and layers.
• You guide by prompting, testing, and iterating, rather than manually typing every line

The shift is that English is now a first-class interface to your codebase.

The following is a simple example.

From user story to scaffolded code

Let us start with a simple product requirement.

Customers can open a basic account online. We capture the name, email, and phone number. We need a simple API to create the account and another to fetch account details by ID.

In a traditional workflow, one would start by designing data contracts and domain models. With vibe coding, you instead give this requirement directly to an AI agent and ask it to scaffold the contracts:

• Request/response records
• Basic validation rules
• Status values or enums

AI tools already handle this effectively. For example, GitHub Copilot can respond to prompts such as the following -

Generate immutable schemas for CreateAccountRequest, CreateAccountResponse, and AccountDetailsResponse suitable for a lightweight HTTP API. The models should be validation‑friendly in shape but must not contain any business logic

You still need to check the data models, names, and consistency, but the tedious task of typing boilerplate code is handled for you. This lets you focus on business rules rather than repetitive syntax.

Letting AI scaffold lightweight APIs

Lightweight APIs are designed to remove ceremony and let you express endpoints concisely. Combined with vibe coding, they become an ideal target for AI-generated scaffolding. You can prompt an agent with something like:

Create lightweight API endpoints for opening an account and getting account details by ID. Use the records we defined, follow REST conventions, and return proper status codes

An AI agent will then generate:

• Endpoint registration or extension methods for organizing routes.
• Request/response bindings using your records.
• Skeleton error handling and basic status codes.

A developer’s role now includes:

• Maintain business rules.
• Align routes and status codes with existing API standards.
• Plug in real data access and domain services.

The Core Tasks: Crafting Prompts, Setting Boundaries, and Evaluation

If vibe coding is not laziness, then what constitutes the actual work? Several possibilities come to my mind.

1. Design-First Prompting: You are no longer typing; you are specifying. Precision in language becomes your primary development tool.
2. Architectural Governance: You choose the tech stack and patterns. The AI is the builder; you are the architect.
3. Human-in-the-Loop Review: Quality is non-negotiable. Every line of generated code requires professional evaluation and potential refactoring.
4. Quality Assurance and Observability: Tools like GitHub Copilot handle syntax, but you must still design the test suites and diagnostic hooks.

You have now shifted from typing code to designing intent and reviewing code.

How to try this safely in your next service

If you want to experiment without wrecking your main codebase:

• Start with a greenfield service – like a simple CRUD API and force yourself to describe every step in natural language before touching code.
• Allow the AI to handle the initial setup, including building classes, data contracts, API routes, and dependency registration. Only commit code you fully understand and approve.
• Gradually codify your patterns into prompts - naming conventions, error envelopes, logging style, and folder structure.
• When you see repetition, turn it into a standard prompt or even an internal tool that your team shares.

You will see a clear distinction. The routine tasks are handled by prompts and generators, leaving behind business logic, system architecture, and discussions with stakeholders.

This shift is not just about speed; it is about reclaiming the developer's role as a system architect rather than a syntax engine.