While many developers have embraced "Vibe Coding," a new paradigm is emerging: managing multiple AI agents to code simultaneously. This approach transforms the developer's role into that of a manager overseeing a team of highly capable AI assistants.

The real work in software development isn't just writing code; it involves research, product strategy, and understanding the core problem to be solved. Agentic coding is incredibly beneficial for anyone building software, as it allows you to offload complex tasks to AI. If your directions are clear and you communicate the problem effectively, these agents can deliver remarkable results. A powerful technique is to run multiple agents in parallel, allowing you to tackle several tasks at once.

From Vibe Coding to Agentic Programming

"Vibe coding" describes the process of collaborating with an AI in a tight feedback loop. You have an idea, you ask the AI to start, you get immediate feedback, and you create something that might have taken weeks or was previously beyond your skillset. This was the first step.

"Agentic coding" is the next evolution. It's less like collaborating and more like managing a capable colleague. You provide a specification or a larger piece of work, hand it off to an agent, and the agent completes it. The feedback loop is less immediate, but it's far more powerful. Imagine trying to manage five human developers who ask for feedback every two seconds—it's impossible.

Modern AI models are adept at following directions. When you provide clear instructions, they can deliver complete pull requests or comprehensive research. You're still giving feedback, but on a much larger chunk of work. This approach requires you to think like a traditional software engineer: what problem are you solving? If you don't know, the AI won't either.

This method is transformative for everyone, including non-engineers. A command-line interface might seem intimidating, but it's just a text-based conversation. When the AI consistently does what you want it to, you experience a kind of magic that goes beyond simple code generation.

The Power of a CLI-Based AI Assistant

Many of the most savvy developers are moving towards CLI-based AI tools. While there are numerous excellent tools available, the key isn't the specific tool but rather rethinking how you work with it.

A typical CLI tool presents a clean, focused interface. Unlike a feature-rich IDE with countless buttons, a blank terminal invites you to do one thing: state your goal.

You can start by simply running the tool: bash claude From there, you can ask it to perform tasks. A great initial use case is learning. You can ask it to analyze a new codebase and explain its purpose, language, and structure.

The AI will create a to-do list to keep itself on track, methodically working through each item. This is the first and most crucial step: research. The AI is exceptional at gathering information by searching the web, accessing your file system, and using any tool available in your command line.

Building a Feature in Just 7 Steps

Let's walk through building a feature using an agentic workflow. Imagine we want to build a simple service that fetches articles, summarizes them, and displays them in a UI.

1. Enter Planning Mode

First, switch the AI into a "plan mode." In this mode, the AI focuses on research and thinking without writing code. This is a best practice; solid upfront research prevents complications later.

2. Define the High-Level Goal

Next, describe the goal in broad strokes. You don't want to be too specific at this stage, as the AI can often fill in details you might miss.

An example prompt:

"I want to research a feature using the built-in article client and a Ruby LM gem. 1. First, add database models for articles to store content from the client. 2. Second, create a service that takes an article and summarizes it using the LM gem. 3. Third, build a UI to read through the summarized articles.

Please research the best approach, create three separate issues for these tasks, and execute them in parallel using sub-agents to save time."

3. Leverage Parallel Processing

Running tasks in parallel is a powerful trick. The AI can spin up multiple sub-agents, essentially opening three separate chat instances to work on each task simultaneously. This orchestrates the work and synthesizes the results.

An added benefit is context window management. Each sub-agent completes its task and returns only a summary, which reduces the number of tokens used in the main conversation, preventing performance degradation over long sessions.

4. Generate and Store the Plan

Once the AI has a plan, have it create markdown files for each issue. This documents the approach and creates a reference point. You can store these on GitHub, where other engineers—or other agents—can pick them up. This provides visibility and allows you to experiment by giving the same task to different AI models to see which performs best.

5. Use Git Worktrees for Simultaneous Development

To implement these three features at once, you can use a Git feature called worktrees. A worktree lets you check out multiple branches into different folders. This prevents agents from overwriting each other's work, much like giving three developers separate workstations.

You can create a simple alias or function to streamline this: ```bash

Example command to create a worktree for "feature-one"

wt feature-one ```

6. Execute the Implementation

With the worktrees set up, you can now kick off an agent in each directory. You can reference the markdown file containing the plan and instruct the AI to begin.

Use trigger words to guide the AI's process. - create to-dos: This tells the AI to generate a step-by-step list. - think ultra hard: This prompt encourages the AI to use more resources and time to produce a higher-quality output, which is useful for complex tasks like planning architecture or considering deployment risks.

7. Review the Code

Once a feature is complete, the agent can automatically create a pull request on GitHub. Reviewing code is still essential. You can even use another AI agent to perform the review. By starting a new agent with a fresh context, it can reflect on the code from a different perspective.

You can even instruct it to review with multiple "hats" on:

"Review this PR with three different hats on: a business person, a security researcher, and a senior architect."

Creating Custom Commands for Efficiency

To maximize laziness and efficiency, create custom slash commands for repetitive workflows. These are simply pre-written, reusable prompts.

For example, you can create a /research_feature command that automates the entire research process: 1. Research the repository: What is the context? 2. Research best practices: Use web search to find grounding information. 3. Present a plan: Outline the proposed solution. 4. Create a GitHub issue: If the plan is approved, formalize it.

This level of automation, where you compound your workflows into reusable commands, is the key to unlocking massive productivity gains.

Final Thoughts: It's a Mindset Shift

The core lesson is to think of AI as a colleague, not just a coding assistant. It can be a product manager, a marketing writer, or a QA tester. It can post a changelog in your voice or triage bug reports.

For those new to this, don't be intimidated. Start with one simple task. Have the AI do something small and see if it succeeds. The goal is to experiment and discover what works for you. Don't try to overhaul your entire workflow at once. Just play with it, and build from there.