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

Source: Dev.to

What is Vibe Coding?

Andrej Karpathy (co‑founder of OpenAI and former AI leader at Tesla) tweeted in February 2025 about “Vibe coding” – a new paradigm where you describe what you want in plain language and let an LLM generate most of the code.

Key ideas

• 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.

From User Story to Scaffolded Code

Example 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 you would first design data contracts and domain models. With vibe coding you 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 instance, GitHub Copilot can respond to prompts such as:

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 verify 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. A typical prompt might be:

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.

Developer’s role

• 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 responsibilities emerge:

Design‑First Prompting

You are no longer typing; you are specifying. Precision in language becomes your primary development tool.

Architectural Governance

You choose the tech stack and patterns. The AI is the builder; you are the architect.

Human‑in‑the‑Loop Review

Quality is non‑negotiable. Every line of generated code requires professional evaluation and potential refactoring.

Quality Assurance and Observability

Tools like GitHub Copilot handle syntax, but you must still design 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

• Start with a greenfield service (e.g., a simple CRUD API) and force yourself to describe every step in natural language before writing code.
• Allow the AI to handle the initial setup, including building classes, data contracts, API routes, and dependency registration. Commit only code you fully understand and approve.
• Codify your patterns into prompts—naming conventions, error envelopes, logging style, 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: routine tasks are handled by prompts and generators, leaving business logic, system architecture, and stakeholder discussions for the developer. This shift is not just about speed; it is about reclaiming the developer’s role as a system architect rather than a syntax engine.