Why I Built AgentCMD

Simply put, I was tired of babysitting my Agents. There's a great reason I was never a babysitter growing up. I have the patience of a hummingbird.

I build a decent amount of Vibe Engineered internal projects for the team at Spectora.com. I'd say my style of coding is "porridge-is-just-right" — smack dab in the middle between Vibe Coding and manually crafting every line like it's 2024.

I primarily leverage a 3 slash command system:

1. generate spec
2. implement spec
3. review spec implementation

This system works incredibly well, but often requires me to call implement multiple times if the spec is complex enough. I've had to call implement 10+ times on larger specs with many phases.

After this Sisyphean implementation process, the review command often finds issues and then it's back to implement. Again. Grrrrrr.

I found myself hovering over my terminal like a helicopter parent, refreshing obsessively. The lazy engineer in me was screaming.

For Me

I decided (much to my wife's chagrin) to embark on a two-month caffeine-sponsored vibe engineering bender to build a solution that would orchestrate these slash commands.

If you're interested in understanding more of the principles of automating your engineering, check out Tactical Agentic Coding by IndyDevDan. I find his content to be quite direct, tactical, and sans-hype. Myself and my whole team took his course. To be honest, it lit a fire under me to build this tool.

PS: Isn't it wild how fast our baseline resets? I'm shipping features in hours that used to take weeks, and I'm still whining about milliseconds of wait. Us Engineers are insufferably fickle creatures.

For My Team

I manage 30+ engineers at Spectora. We're deep into Claude Code adoption, building reusable slash commands to template our workflows. What I've learned: every team needs slightly different things.

• Slightly different slash commands
• Slightly different steps
• Different processes to complete the SDLC for their specific project

I tried various swarm projects and all the open source Claude "Bips and Bops" to see if anything would support our nuanced enterprise needs. We're not generally building greenfield projects. We have all the glory (and shame) of a 5+ year old Rails monolith and many growing supporting monorepos.

Enter AgentCMD

AgentCMD isn't trying to be Devin (remember when the bastard was coming for our jobs?). It's just orchestrating Claude Code and other agentic coding tools, powered by your brain and experience.

It's more of a framework than the world's next super agent.

Beyond enforcing spec-driven development, it's unopinionated. You define how your agents code, review, and ship.

This was crucial — my teams have wildly different needs.

How Does This Work?

Every workflow is powered by workflow files you define in your source projects. Here's an example:

import { defineWorkflow } from "agentcmd-workflows";
import { buildSlashCommand } from "../generated/slash-commands";

// Example: Implement & Review Workflow
export default defineWorkflow(
  {
    id: "implement-review-workflow",
    name: "Implement Review Workflow",
    phases: [
      { id: "implement", label: "Implement" },
      { id: "review", label: "Review" }
    ],
  },
  async (({ event, step }) => {
    const { workingDir, specFile } = event.data;

    await step.phase("implement", async () => {
      const response = await step.agent(
        "implement-spec",
        {
          agent: "claude",
          json: true,
          prompt: buildSlashCommand(
            "/cmd:implement-spec",
            { specIdOrNameOrPath: specFile, format: "json" }
          ),
          workingDir
        }
      );
      return response;
    });

    await step.phase("review", async () => {
      await step.agent(
        "review-spec-implementation",
        {
          agent: "claude",
          json: true,
          prompt: buildSlashCommand(
            "/cmd:review-spec-implementation",
            { specIdOrNameOrPath: specFile, format: "json" }
          )
        }
      );
    });
  }
);

It's just code. Your code. Your workflow. Your complex, domain-specific hodgepodge of commands and steps.

Looking Ahead

2025 was a whirlwind, eh? We all know engineering is changing in a fundamental way. That said, I don't think engineering jobs are going anywhere — they're (ani)morphing.

I expect in 2026 for engineering to shift far more towards:

• Planning specs: defining what to build, breaking it into phases, anticipating edge cases
• Reviewing code: validating AI output, catching hallucinations, ensuring quality
• Orchestrating agents: chaining tools together, building workflows, knowing when to intervene

...instead of banging on the keys.

The skill ceiling isn't lowering — it's shifting. Deep knowledge of your codebase, architecture, and domain still matters. Maybe more than ever. The difference is that execution speed is no longer the bottleneck. Thinking clearly is.

We're pretty much already there. Between Superwhisper and using AgentCMD to build itself, I hardly write a manual line of code these days. My job has become less about typing and more about directing — like a conductor who doesn't play every instrument but knows exactly how they should sound together.

If you're interested in trying it out or have questions, feel free to reach out on Twitter. And if you're also tired of helicopter-parenting your agents, welcome to the club.