Vibe coding: the shift to agentic workflows

Coding used to mean translating intent into syntax, line by line. Agentic workflows flip that: you state the intent, and a loop of tools does the typing.

I’ve spent the last decade building Laravel applications, managing Docker clusters and fine-tuning Shopify stores.

For most of that time, “coding” meant one thing: translating a business requirement into syntax a machine could execute. It was a manual, linear process of writing line by line, debugging stack traces and managing state.

Recently, the ground has shifted. We’re moving away from “writing code” and into “orchestrating intent.”

This transition is often playfully called vibe coding. The meme hides a real architectural change: a move from sequential instructions to agentic workflows powered by protocols like MCP (Model Context Protocol).

If you are new to the idea, my intro to vibe coding covers the philosophy and developer-experience side before this post dives into the architecture.

The friction of manual syntax

The traditional development lifecycle is full of invisible friction. You have an idea (the “vibe”), you break it into tasks, and then you spend 80% of your time fighting syntax, configuration and boilerplate.

In a standard Laravel environment, even a simple feature like an automated reporting tool needs routes, controllers, service classes and database migrations.

You are the compiler. You are the architect. You are the labor.

The “how” eats the “what”

Our cognitive load gets consumed by the “how” rather than the “what.” We get stuck on PHP version compatibility or Docker networking issues and lose sight of the actual user value.

This manual micromanagement doesn’t scale with the demands of modern business.

The “black box” assistant problem

When AI first arrived as basic autocomplete, it felt like a shortcut. It wasn’t a solution.

We ended up with what I call “the Copilot paradox”: the AI suggests code, but you still copy-paste it, test it, find the error and feed it back.

A broken feedback loop

The AI is a “black box” that doesn’t know your system. It doesn’t know your database schema, your MCP servers or your deployment status on Coolify.

You are still the manual bridge between the AI’s logic and your local environment.

Accelerated manual labor

This creates a new kind of fatigue. Instead of writing code, you become a high-speed code reviewer, constantly switching between your editor and a chat window.

That isn’t “vibe coding.” It’s accelerated manual labor.

The fix: agentic workflows and MCP

True vibe coding shifts your role to high-level system architect.

That becomes possible through agentic workflows: systems that execute tasks in loops instead of only completing text. That jump from a static model to an autonomous actor is exactly the LLM vs AI agent distinction.

MCP is the connector

The breakthrough here is the Model Context Protocol (MCP), created by Anthropic and donated in December 2025 to the Agentic AI Foundation, a Linux Foundation fund, so it is now vendor-neutral.

MCP acts as the “USB-C port” for AI applications. Instead of you handing the AI context, the AI uses an MCP client to talk directly to your tools: your PostgreSQL database, your Slack channels or your GitHub repositories.

From chains to loops

In a traditional chain, you give a prompt and get a result. In an agentic loop, the architecture looks like this:

1. Intent. You describe the outcome (“build a Laravel dashboard for my Shopify sales”).
2. Reasoning. The AI (like Claude) works out that it needs to see the schema.
3. Action. It uses an MCP tool to query the database.
4. Observation. It sees a missing table and decides to create a migration.
5. Correction. If the migration fails, it reads the error and fixes it itself.

Intent-based engineering

I call this “intent-based engineering.” You aren’t writing the migration. You are approving the architectural decision.

Nobody lands here on day one. The jump from chat prompts to loops is a progression I broke into levels of an AI coding workflow, and MCP sits near the top of it.

Implementing the agentic stack

As an engineer who values quality, I don’t let the “vibe” take over without guardrails.

The loop only stays safe if something verifies what comes out of it. That is the whole argument in trust is not a QA strategy. Here is how I structure my agentic stack using Laravel and AI today.

1. Defined MCP servers

I build small, dedicated MCP servers that expose only the tools the AI needs. This keeps the context window clean and the security tight.

I go deeper on this in Claude MCP dev tools and on designing context-aware agents with MCP.

// Conceptual MCP tool definition in a PHP environment
public function defineTools(): array
{
    return [
        'get_database_schema' => [
            'description' => 'Retrieves the structure of the Laravel application tables.',
            'parameters' => [],
        ],
        'run_artisan_command' => [
            'description' => 'Executes an artisan command safely.',
            'parameters' => ['command' => 'string'],
        ],
    ];
}

2. Stateful loops

Instead of one-off chats, I use tools like Cursor, Claude Code or Devin Desktop (the IDE formerly called Windsurf) that keep a stateful connection to my local file system.

The agent can “see” the impact of its changes in real time, just like a human developer would.

3. The human-in-the-loop (HITL)

The most important part of the architecture is the review gate. Even with agentic loops, the human architect must sign off on the “plan” before the “action” phase.

This keeps the PHP logic on clean architecture principles rather than just “making it work.”

What that gate should actually check is a separate question. I argue for dropping line-by-line reading in favor of specs and automated verification, and I cover approval gates for writes in HITL gates for agent mutations.

What this means for founders

If you’re a founder or a CTO, the lesson is simple: stop hiring for syntax and start hiring for system design. The technical barrier is collapsing, but the architectural stakes are higher than ever.

• Embrace the vibe. Focus on the intent and the user experience.
• Invest in infrastructure. Build the MCP connections and data pipelines that let AI be effective.
• Think in loops. Design internal processes so AI can iterate on its own, which removes you as the bottleneck.

I now build agent-ready systems, whether it’s a complex Shopify integration or a custom SaaS, so the architecture is ready for agents from day one.

If you want to move your team from chat prompts to scoped agent loops on Laravel and MCP, here’s how I help teams design and ship that stack, or get in touch directly.

Are you ready to stop writing code and start orchestrating your intent?