In February 2025, Andrej Karpathy coined a term that took over the tech world: vibe coding --- writing code by describing what you want to an AI, letting it handle the syntax.

One year later, Karpathy says vibe coding is already passé.

The new paradigm? Agentic engineering --- where you’re not writing code 99% of the time. You’re orchestrating AI agents who write it for you, acting as oversight rather than author.

And the orchestration tool? Markdown.

The Evolution: Three Phases

Software 1.0: Write the Code

Traditional programming. Humans write every line. Python, JavaScript, C++. You think in syntax, debug manually, and iterate line by line.

Software 2.0 / Vibe Coding: Describe the Code

AI assistants like Copilot and Cursor generate code from natural language descriptions. You “vibe” with the AI --- describing what you want, accepting or rejecting suggestions. You still review every line.

Software 3.0 / Agentic Engineering: Direct the Agents

AI agents operate autonomously. You write a Markdown file defining goals and constraints. The agent writes code, tests it, iterates, and commits improvements. You review the results, not the process.

Karpathy’s autoresearch is the clearest example: a researcher writes program.md, and the AI runs 100+ experiments overnight without human intervention.

Markdown: The Interface Layer

In each phase, the human’s tool changes:

Phase	Human’s Tool	Output
Software 1.0	Code editor	Source code
Software 2.0	AI chat + code editor	AI-assisted source code
Software 3.0	Markdown editor	Agent instructions

In agentic engineering, the Markdown file IS the product of human work. Everything downstream --- the code, the experiments, the results --- is produced by AI agents following your Markdown instructions.

The New Skill: Writing Agent Instructions

If you’re not writing code anymore, what ARE you doing? You’re writing Markdown files that are clear, specific, and strategically sound.

This requires a different skill set:

Domain expertise --- You need to know what good results look like, even if you’re not producing them manually.

Clear writing --- Ambiguous instructions produce ambiguous results. The better your Markdown, the better the agent’s output.

Strategic thinking --- In autoresearch, the researcher’s job is setting the right research direction, not running individual experiments. Your program.md defines the strategy.

Evaluation ability --- You need to judge whether the agent’s results are actually good. Oversight is the human’s core responsibility.

What You’re Really Programming

When you write a program.md, an AGENTS.md, or a CLAUDE.md, you’re not just writing documentation. You’re programming:

Goals: What should the agent optimize for?
Constraints: What should the agent never do?
Context: What does the agent need to know about the domain?
Strategy: How should the agent approach the problem?
Evaluation: How should the agent measure success?

This is Software 3.0 programming. The language is Markdown. The compiler is an LLM. The runtime is an autonomous agent loop.

The Knowledge Supply Chain

Agentic engineering depends on knowledge. Your Markdown instructions are only as good as your understanding of the domain. This creates a knowledge supply chain:

Capture knowledge from the web (documentation, papers, blog posts, examples)
Organize it in a Markdown-native system (Obsidian, Notion, plain files)
Synthesize it into agent instructions (program.md, AGENTS.md, CLAUDE.md)
Deploy agents that execute on your instructions

The first step --- capturing web knowledge as Markdown --- is where Save fits in. One-click conversion of any webpage to clean Markdown, ready to feed into your agent instruction workflow.

The people writing the best agent instructions in 2026 aren’t starting from scratch. They’re building on a carefully curated library of Markdown references.

Getting Started with Agentic Engineering

You don’t need to be running autoresearch to practice agentic engineering:

Start with AGENTS.md in your current project. Write clear instructions for AI coding assistants.
Iterate based on results. When the AI makes a mistake, don’t just fix it --- update your Markdown instructions so it won’t happen again.
Build your reference library. Save useful documentation, examples, and best practices as Markdown. You’ll reference them when writing agent instructions.
Think strategically. Instead of telling the AI what code to write, tell it what problem to solve and what constraints to respect.

The shift from vibe coding to agentic engineering isn’t a future prediction. It’s happening right now, and Markdown is the interface.

Save converts any webpage to clean Markdown --- building the knowledge library that powers effective agentic engineering. Try Save free.