Vibe coding history: From AI assistance to Andrej Karpathy’s 2025 coinage

Coined by Andrej Karpathy in February 2025, "vibe coding" is the practice of building software through natural language rather than manual syntax. Instead of writing code, you describe the desired outcome, run the AI-generated app, and prompt for iterative revisions. Although the underlying AI tools had long existed, the term signals a distinct cultural shift: Away from basic AI code completion and toward structured, agent-driven development workflows.

What is vibe coding, and who coined the term?

What is vibe coding history: The short answer

Vibe coding is an informal software-development workflow coined and popularized by Andrej Karpathy on February 2, 2025. A person gives natural-language instructions to a large language model, tests the generated code, reports errors or desired changes, and repeats the process-often without closely inspecting every implementation detail.

Vibe Coding history

A large language model (LLM) is an AI system capable of generating and transforming text, including source code, from natural-language input.

Vibe coding prioritizes intent over implementation. The person defines what the software should do, while the model decides how to produce or modify much of the underlying code.

In its narrow original sense, the workflow looks like this:

1. Describe the desired behavior in natural language.
2. Generate or modify the implementation with an LLM.
3. Run the application or feature.
4. Inspect the visible result, error message, or unexpected behavior.
5. Return feedback to the model and repeat.

This differs from conventional AI pair programming, where developers generally read, assess, and edit individual suggestions inside their code editor. In vibe coding, attention may remain primarily on whether the application behaves as expected.

What Karpathy originally meant

Karpathy’s description captured a recognizable prompt-run-debug loop. A person might request a small dashboard, run the generated application, copy an error back into the conversation, and ask the model to fix it.

This loop can continue without the user having to directly write much of the source code.

• “Create a landing page with an email signup form.”
• “The mobile navigation overlaps the headline.”
• “Store submissions in a database.”
• “The form returns this error.”
• “Make the layout closer to this screenshot.”

The model generates or revises the implementation after each instruction. The person guides the result through conversational iteration, rather than controlling every line.

Vibe coding is not currently regarded as a formal methodology within software engineering. Karpathy’s original post was an informal, humorous description of a working style-not a software engineering standard or a recommendation for production systems.

Why the attribution needs qualification

Karpathy coined the memorable phrase, but he did not invent AI code generation, natural-language programming, or conversational development.

A developer who uses AI to draft a function, reviews every line, adds tests, and validates its behavior is using AI-assisted programming. That workflow does not necessarily fit the narrow vibe coding definition.

What made vibe coding possible before 2025?

Vibe coding did not emerge from one model, company, or product launch. It became possible through a gradual shift in how people interacted with software-development tools.

The key progression was from predefined visual abstractions to AI suggestions, conversational revision, multi-file editing, and increasingly independent task execution.

No-code and visual development as conceptual antecedents

No-code and visual development platforms helped normalize the idea that people could build software without directly writing every line. Users assembled predefined components, configured workflows, and judged progress through visible results.

However, no-code development is not an earlier form of vibe coding. No-code platforms mainly hide source code behind controlled abstractions. Vibe coding uses generative models to create or modify implementation dynamically.

The connection is cultural and interface-based: Both approaches reduce direct contact with syntax and emphasize describing or configuring desired outcomes.

LLMs turn natural language into a development interface

Code-generation models made natural language a practical interface for software creation. Instead of searching documentation and translating every requirement manually, developers could ask a model to draft functions, explain errors, transform code, or propose fixes.

Several developments supported this transition:

• Models became more capable of generating useful source code.
• Chat interfaces enabled multi-step debugging conversations.
• APIs allowed code generation to be embedded inside development products.
• Larger context windows helped tools reason across longer files and broader project context.

OpenAI’s 2020 API release helped make general-purpose language models accessible to software products. Its later ChatGPT and Whisper APIs, released on March 1, 2023, made conversational AI integration more accessible to developers.

These milestones did not create vibe coding by themselves. They helped establish the technical foundation for natural-language coding and conversational revision.

GitHub Copilot and the AI Pair-Programming Era

GitHub Copilot marked an important normalization point for AI assistance inside professional development environments. GitHub announced its technical preview on June 29, 2021, presenting Copilot as an AI pair programmer.

Before Copilot-style workflows, developers typically searched documentation, consulted forums, and wrote most implementation details manually. With AI code completion, suggestions appeared directly inside the editor.

Developers could then:

• Read a proposed function or code block.
• Accept, reject, or modify the suggestion.
• Continue writing with implementation-level visibility.
• Test the resulting behavior through familiar development processes.

Human oversight generally remained higher than in narrow vibe coding. The developer still worked directly with the source code and made granular acceptance decisions.

From Autocomplete to Coding Agents, 2023–2024

AI coding tools gradually moved beyond single-line completion:

Single-line suggestion → Chat-based revision → Multi-file editing → Terminal and tool usage → Bounded task delegation

A repository-aware agent can inspect multiple files and use broader codebase context before proposing or applying changes. This allows the tool to handle tasks such as updating an API, modifying related tests, and adjusting dependent files.

GitHub announced the technical preview of Copilot Workspace on April 29, 2024, describing a task-oriented environment that could move from a natural-language idea toward a plan and implementation.

Other coding tools also developed agent-like capabilities during 2024. The important historical change was not which vendor arrived first. It was the transition from passive suggestions toward tools capable of planning and executing bounded, multi-step tasks.

Comparison: Vibe coding and its predecessors

The following distinctions prevent “vibe coding” from becoming a catch-all label for every technology-assisted workflow.

Human oversight is the clearest practical boundary. Using an AI tool does not automatically make a workflow vibe coding.

February 2025: How the term “vibe coding” began

The February 2 Post

On February 2, 2025, Andrej Karpathy published the X post that introduced “vibe coding”. Karpathy is a computer scientist, OpenAI co-founder, and former Tesla AI leader.

Karpathy described a personal workflow in which he would, in his words, “fully give in to the vibes, embrace exponentials.”

The surrounding description emphasized reduced attention to the underlying code. In practical terms, Karpathy was describing a process where the running result and conversational feedback mattered more than direct implementation-level control. The wording was intentionally informal. It presented a recognizable experience rather than a documented engineering framework.

The original workflow in plain language

Karpathy’s description can be translated into five practical actions:

1. Describe what the application or feature should do.
2. Generate the implementation through an AI model.
3. Run the resulting software.
4. Return errors, screenshots, or requested changes to the model.
5. Repeat until the visible behavior appears acceptable.

The developer may spend more attention evaluating behavior than reading the generated implementation. For a small internal tool, this could mean asking an AI to scaffold a CRUD application-a tool that creates, reads, updates, and deletes records. The person tests the interface, reports failures, and requests changes without manually working through every file.

Why the name spread so quickly

The phrase spread because it gave developers a compact label for an existing behavior. Four factors made it especially portable:

• Memorable phrasing: “Vibe coding” was humorous and easy to repeat.
• Recognizable behavior: Developers were already prompting models, running code, and returning errors.
• Improved model capability: AI systems could handle larger and more connected development tasks.
• Social-media portability: The expression communicated a complex workflow in two words.

The term captured both excitement about development speed and discomfort about reduced implementation-level control. That tension helped it travel beyond Karpathy’s original post.

How vibe coding entered mainstream culture in 2025

From Developer Joke to Shared Industry Vocabulary

During 2025, vibe coding moved from AI and developer communities into founder discussions, technology reporting, product conversations, and general public vocabulary. This movement was not a clean sequence. Developers, founders, journalists, and tool vendors often used the phrase differently at the same time.

Some used it narrowly for Karpathy’s low-oversight workflow. Others applied it to almost any software creation involving prompts. Technology reporting made the phrase accessible to non-specialists, while startup communities connected it with rapid product experimentation.

Merriam-Webster later documented vibe coding as a slang and trending term. Such recognition demonstrates cultural visibility, not technical reliability or formal standardization.

Why founders and non-developers adopted it

Vibe coding appealed to people who wanted to test software ideas without first mastering every language, framework, or development tool.

Potential benefits included:

• Faster prototype cycles.
• Lower syntax and tooling barriers.
• Immediate visible feedback.
• Earlier idea validation.
• Lower initial experimentation costs.

Suitable early use cases included:

• Product demonstrations
• Landing pages
• Personal productivity tools
• Small internal applications
• Disposable experiments
• Early interface prototypes

These benefits do not remove engineering requirements. Applications handling sensitive data, payments, permissions, critical infrastructure, or complex integrations require structured review by qualified professionals.

A functional demonstration is also not necessarily production-ready code. Production readiness involves appropriate testing, security review, deployment controls, observability, maintenance planning, and clear ownership.

Weighted timeline of vibe coding history

This timeline emphasizes the developments that made the phrase and workflow historically significant.

The timeline shows why vibe coding history cannot begin only in February 2025. That date marks the origin of the phrase, while the enabling practices developed over several years.

How the meaning of vibe coding changed

From a specific workflow to a general label

Semantic drift is the process through which a term develops broader or different meanings over time. Vibe coding moved through at least three overlapping meanings:

The broadened usage can obscure major differences. A developer reviewing every AI-generated change is following a different process from someone shipping code based only on visible behavior. Disciplined AI-assisted engineering should therefore not automatically be labeled vibe coding.

Why some developers use the term negatively

The negative meaning emerged from concerns about insufficient verification rather than AI authorship alone.

Common risks may include:

• Hidden defects behind apparently correct behavior
• Difficulty explaining generated logic
• Architectural inconsistency across larger codebases
• Unexpected changes during repeated generation
• Security or data-handling mistakes
• Increased review and remediation work
• Unclear responsibility for generated decisions
• Technical debt, meaning future maintenance costs caused by expedient or poorly understood implementation choices

A generated feature can appear functional while failing under unusual inputs, higher traffic, changed permissions, or external service failures. Rapid generation may transfer effort from implementation to later review and repair.

These problems are not unique to AI-generated software. Human-written code can contain the same defects. The risk increases when generated output receives less scrutiny because it was fast to produce or appeared correct during a limited demonstration.

The person and organization shipping the software remain accountable for its behavior. An AI model cannot assume legal, operational, or engineering ownership.

The balanced interpretation

Vibe coding can be useful for fast exploration and disposable experiments. It becomes risky when generated code bypasses understanding and verification. The practical question is whether the output was reviewed, tested, secured, documented, and assigned to responsible maintainers.

From vibe coding to agentic engineering

The emerging idea of agentic engineering describes a more structured approach to AI-assisted software development. The term is not a universally standardized methodology, but it helps distinguish controlled orchestration from low-oversight generation.

The transition is not simply from humans writing code to agents writing code. It shifts human effort toward intent, context, constraints, verification, and governance.

The developer becomes an orchestrator

In an agentic workflow, developers may delegate implementation tasks while retaining control over boundaries and approval.

The developer must still understand architecture, failure modes, dependencies, and trade-offs. Orchestration without engineering knowledge can make incorrect assumptions harder to detect.

A controlled workflow should establish:

• What the agent may modify.
• Which tools and commands it may use.
• What evidence it must produce.
• Which tests must pass.
• Who reviews security-sensitive logic.
• Who approves deployment.
• Who owns the resulting software.

Vibe and verify

A practical middle ground is to combine fast generation with explicit verification.

Automated tests provide useful evidence, but they do not prove complete correctness. A second AI agent may assist with review, yet it cannot assume accountability for the decision to ship.

Authentication, authorization, payments, encryption, personal data, and destructive operations require qualified human review.

A practical boundary for production use

Pure vibe coding optimizes for speed and experimentation. Agentic engineering aims to preserve AI leverage while adding context, constraints, tests, permissions, and approval gates. Production readiness still depends on review, security, observability, deployment discipline, maintainability, and human ownership.

Frequently asked questions

What is vibe coding and where did the term come from?

Vibe coding is an AI-assisted software development method where developers use natural language to describe intent, allowing LLMs to generate code. The term was coined and popularized by Andrej Karpathy on February 2, 2025, to describe a workflow prioritizing conversational iteration over manual implementation.

Is vibe coding safe for production software?

Generally, no. While vibe coding is efficient for prototyping, it poses risks for production systems. AI-generated code may contain subtle logic errors, security vulnerabilities, or architectural flaws. Professional environments require rigorous human oversight, automated testing, and security reviews-a practice often called "vibe and verify."

How did the term "vibe coding" evolve?

The term originated as a specific, informal description of an AI-first workflow. Over time, it underwent "semantic drift," broadening to cover almost any AI-assisted coding. Critically, it is now often used to describe the dangers of shipping AI-generated code without sufficient human verification or architectural understanding.

What is the difference between vibe coding and agentic engineering?

Vibe coding focuses on natural language prompts to quickly generate visible output with low oversight. Agentic engineering is a more structured evolution, using AI agents to execute multi-step workflows while maintaining formal controls, such as defined tasks, automated test gates, security audits, and human approval processes.

Does vibe coding replace the need for professional developers?

No. Vibe coding shifts the developer’s role rather than eliminating it. As implementation becomes automated, the value of engineering expertise increases in areas like architecture, system integration, security validation, and project accountability. The developer acts as an orchestrator and final quality gatekeeper for the AI's output.

Why is vibe coding often associated with technical debt?

Vibe coding can lead to technical debt when developers accept AI-generated code without fully understanding its underlying logic. This creates a "black box" codebase that becomes difficult to maintain, debug, or scale when the AI’s initial output needs adjustment or when complex, multi-file architectural changes are required.

Read more:

• Is vibe coding bad? Pros, cons and responsible AI practices
• Vibe coding vs traditional coding: Which approach wins?
• How to vibe code: A practical beginner guide to AI development

Conclusion

The short version of vibe coding history begins with Andrej Karpathy’s February 2, 2025 post, but the underlying practice is older. LLM code generation, GitHub Copilot, conversational debugging, and repository-aware agents had already shifted development from direct authorship toward prompting and delegation. The term later broadened from Karpathy’s low-attention workflow into a general label-and sometimes a criticism-for AI-assisted coding with insufficient review.

Fast generation remains useful for prototypes and experiments. Production software requires understanding, testing, security controls, observability, maintenance, and accountable ownership.

AgentKit reflects the move toward controlled agentic engineering by coordinating specialized agents, reusable skills, tests, security checks, and human approval gates. Explore AgentKit’s educational resources for controlled agent workflows to build a practical AI-generated code review process.