My "Vibe Coding" process atm

(if you need a primer on vibe-coding, look to IBM’s brief article. Note that what I’m doing is certainly vibe coding, but I’m attempting to approach development in a more repeatable, scalable and predictable fashion).

This is the way I'm currently running multiple Claude Code CLI instances for small but complicated projects (at least complicated for me, a non-developer, but a background in infrastructure engineering). Unfortunately this model requires significant human oversight to maintain alignment. I'm actively exploring more automated orchestration approaches like Microsoft AutoGen and Claude Code SDK integration to reduce the coordination burden while maintaining the benefits of specialized agent roles. I find that this model keeps my context windows cleaner with far fewer frustrating auto-compacts.

I’ve also built a multi-project repo structure that uses Claude.md up and down the project chain for consistency of TDD/Lint/Hooks. More on that process soon.

You can find my repo here.

Current Setup

Directory Structure

My multi-agent system relies (too) heavily on structured directories to organize communication. Causes a lot of complexity in communication. Note the missing /.claude/claude. I need to figure that out:

project/
├── CLAUDE.md                   # Project memory and instructions
├── dev_team/                   # Team coordination hub
│   ├── COORDINATION_PLAN.md    # Overall project structure
│   ├── TEAM_STRUCTURE.md       # Role definitions
│   ├── AGENT_PROMPTS.md        # Specialized prompts for each role
│   ├── roles/                  # Role-specific instructions
│   ├── communication/          # Message exchange hub
│   │   ├── YYYY-MM/            # Monthly directories
│   │   │   ├── YYYY-MM-DD_ROLE_topic.md # Messages
│   ├── tasks/                  # Task assignments
│   ├── status/                 # Status reporting
│   └── integration/            # Cross-team integration
└── scripts/                    # Coordination scripts

Core Roles

I typically run several specialized Claude Code agents. Not always at the same time. And I find I need to be very careful to not run them in the wrong sequence. And am thinking of adding a git manager, but maybe pre-commit hooks as a protocol will work Then again, see issues below; maybe not.

1. Manager (PM): Oversees the project, coordinates teams, maintains project status

2. Backend Developer: Implements API and server logic

3. Frontend Developer: Implements UI components and client-side logic

4. Data Service Developer: Handles data integration and processing

5. Data Analyst: Analyzes data structures and patterns

6. Business Analyst: Defines requirements and specifications

7. Tester: Creates and runs tests, validates implementations

Inter-Agent Communication Flow

The communication between agents follows a specific manual pattern that I orchestrate. Meaning, when I see an agent has completed a task/run and created a status update, I copy the path and paste it in the manager context (or different agent) and instruct the manager to update the plan and give me the next prompt:

Request-Response-Next Pattern

1. Initial Request: Manager agent sends a request document to a specialized agent

/dev_team/communication/2025-05/2025-05-01_PM_DA_data_model_enhancement.md

1. Developer Response: Specialized agent completes the task and creates a response document

/dev_team/communication/2025-05/2025-05-01_DA_contact_model_enhancement_response.md

1. Manual File Path Transfer: I manually copy the response file path and provide it to the Manager agent

Please read the Data Architect's response at:
/dev_team/communication/2025-05/2025-05-01_DA_contact_model_enhancement_response.md. Update the project documentation and todo list, then give me the next 2nd person prompt in the sequence. Be sure to include a communication and git policy reminder. 

1. Manager Processing: Manager reviews the response, updates status and todos, and provides:

   • Next steps for the project

   • Updated sequence for agent execution

   • 2nd person prompt for the next agent in the sequence

2. Sequence Continuation: I then launch the next agent with the provided prompt:

You are the X agent.  Please see the update from the manager and follow the tasks /dev_team/communication/2025-05/2025-05-03_PM_agent_execution_sequence.md

Examples of Prompts and Communication

Project Manager creates specialized prompts for each agent role:

You are the Tester for the Next Up project, a professional networking application.

Focus on validating implementations against real-world data with emphasis on accuracy, reliability, and alignment with requirements. Your responsibilities include:

1. Designing test plans using real contact data
2. Executing tests on implemented components
3. Validating classification accuracy against known information
4. Documenting test results and discrepancies
5. Providing feedback on implementation improvements
6. Following the communication protocol in COMMUNICATION_PROTOCOL.md
7. Following the git protocol in GIT_PROTOCOL.md

Your immediate priority is to test the industry classification implementation...

These role-specific prompts are supposed to help maintain agent specialization and focus. I am not sure how much they do - I often find context drift over time, so I have the project manager give me full prompts with all the instructions again (and paths). The only problem is that it eats context window space.

Status Updates and Todo Management

1. Each agent maintains its own internal todo list during sessions

2. Manager consolidates todos into a central project tracking document

3. I need to frequently remind agents to update their status documents:

/dev_team/status/STATUS_DATA_SERVICE.md
/dev_team/status/STATUS_BACKEND.md

Workflow

Session Management

For each work session:

1. Start Manager agent first ("claude" in terminal)

2. Ask Manager to review status and tell me where we are and our planned work for the date and give me for specialized prompts for each agent I need next

3. Open additional terminal windows for specialized agents as needed

4. Each specialized agent reads their role instructions and latest communications

5. Constantly monitor file organization and policy adherence. Get frustrated with dumb mistakes and reset the context window (this winds up being important).

Internal Todo Management

Agents maintain their own internal todo lists but often need reminders to update central project tracking. Manager maintains the most comprehensive task tracking, but limited visibility between agents' individual todos creates coordination challenges.

Test-Driven Development

Recently implemented TDD with agents following the test → implement → refactor sequence, though they need frequent reminders to maintain this discipline.

Git Workflow

Established role-based branching strategy with standardized commit messages and helper scripts, but agents need constant reminders to follow the protocol.

Challenges Encountered

Behavior Management Challenges

• Defaulting to synthetic data despite explicit instructions

• Creating new scripts instead of fixing existing ones causes proliferation

  • Multiple similar files consume valuable context window space

• Inconsistent file placement in the directory structure

Workflow Control Challenges

• Agents continue on problematic paths without waiting for validation

• Inconsistent following of established processes

• Need to supervise decisions before execution to prevent issues

Integration Challenges

• Asynchronous work creates handoff problems between roles

• Assumptions about APIs and data structures cause misalignments

• Security boundaries and configuration settings not communicated clearly

Future Directions

AutoGen Exploration

I'm exploring Microsoft's AutoGen as a potential orchestration platform that could a lot of value to my workflow. But I am worried about things spinning out of control (see issues above):

• Provide more structured agent interaction patterns

• Handle conversation routing between agents

• Manage context more efficiently

• Implement formal workflow transitions

• Track agent state across interactions

Headless Claude Code CLI

Investigating headless Claude Code CLI calls to:

• Force smaller units of build/test

• Create more focused, context-efficient agents

• Enable more programmatic coordination

• Automate transitions between agents

• Script agent interactions for repeatable workflows

Model Hybrid Approach

Exploring a mixed-model strategy:

• ChatGPT/GPT- o3 for PRD/specifications development

• Claude Code for implementation, testing and technical work

• Specialized models for specific tasks

Enhanced Integration Points

• Pre-commit hooks for automated testing

• Formal interface contract verification

• Structured data validation between agents