Project Workflow Skill

Overview

This skill defines the development workflow patterns for the Codebase Singularity framework, including the core Plan-Build-Review-Fix cycle and feature development processes.

Core Workflow: Plan-Build-Review-Fix

The foundational workflow for all development:

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│   ┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐│
│   │  PLAN   │───►│  BUILD  │───►│ REVIEW  │───►│   FIX   ││
│   └─────────┘    └─────────┘    └─────────┘    └────┬────┘│
│        ▲                                            │      │
│        │              Loop until                    │      │
│        └────────────  quality passes ◄──────────────┘      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Phase 1: Plan

Command: /plan [feature] Agent: planner

Activities:

1. Understand requirements
2. Analyze existing code
3. Research solutions
4. Design architecture
5. Create implementation plan

Output: specs/[feature]-plan.md

Phase 2: Build

Command: /build Agent: builder

Activities:

1. Read implementation plan
2. Create/modify files
3. Write core logic
4. Add error handling
5. Create basic tests

Output: Working code + tests

Phase 3: Review

Command: /review Agent: reviewer

Activities:

1. Check code quality
2. Verify logic correctness
3. Security analysis
4. Performance check
5. Test coverage check

Output: specs/reviews/[date]-review.md

Phase 4: Fix

Command: /fix Agent: fixer

Activities:

1. Address review findings
2. Fix issues by priority
3. Verify fixes
4. Re-run affected tests

Output: Fixed code + verification

Workflow Patterns

Feature Development

1. /prime        # Load context
2. /plan         # Design feature
3. /build        # Implement
4. /review       # Quality check
5. /fix          # Address issues
6. [Repeat 4-5 until passing]
7. git commit            # Save work

Bug Fix

1. /prime        # Load context
2. [Investigate bug]     # Understand issue
3. /plan bugfix  # Plan the fix
4. /fix          # Implement fix
5. /review       # Verify fix
6. git commit            # Save work

Refactoring

1. /prime        # Load context
2. /review       # Identify issues
3. /plan refactor # Plan changes
4. /build        # Implement refactor
5. /review       # Verify improvement
6. git commit            # Save work

Complete Cycle Command

Command: /cycle [feature]

Runs the complete Plan-Build-Review-Fix cycle:

Step 1: Planning
├── Read requirements
├── Analyze codebase
├── Create plan
└── Get approval

Step 2: Building
├── Implement plan
├── Create tests
└── Show progress

Step 3: Reviewing
├── Quality check
├── Security check
└── Generate report

Step 4: Fixing (if needed)
├── Address findings
├── Verify fixes
└── Re-review

Step 5: Complete
├── Summary
├── Files changed
└── Next steps

Quality Gates

Before Building

• Plan approved
• Requirements clear
• Dependencies identified
• Approach validated

Before Committing

• All tests pass
• Review score ≥ 7/10
• No critical issues
• No security vulnerabilities

Before Release

• Feature complete
• Full test coverage
• Documentation updated
• Security audit passed

Agent Coordination

Single Agent Tasks

Task	Agent
Create plan	planner
Write code	builder
Review code	reviewer
Fix issues	fixer
Write tests	test-writer
Fetch docs	doc-fetcher
Security check	security-auditor
Improve code	refactorer

Multi-Agent Workflows

Feature Development:

planner → builder → test-writer → reviewer → fixer

Security Audit:

reviewer → security-auditor → fixer → reviewer

Documentation:

doc-fetcher → builder (docs) → reviewer

Workflow Commands Reference

Command	Purpose
/prime	Initialize session
/plan	Create implementation plan
/build	Build from plan
/review	Review code quality
/fix	Fix review issues
/cycle	Complete workflow
/orchestrate	Multi-agent coordination
/delegate	Direct agent invocation

Best Practices

Planning

• Be thorough but concise
• Consider edge cases early
• Plan for testing
• Identify risks upfront

Building

• Follow the plan
• Write clean code
• Test as you go
• Ask when unclear

Reviewing

• Be constructive
• Provide solutions
• Prioritize findings
• Acknowledge good work

Fixing

• Fix one issue at a time
• Verify each fix
• Don't introduce new issues
• Document changes

Workflow Troubleshooting

Plan Not Detailed Enough

• Ask for clarification
• Review similar features
• Break into smaller steps

Build Taking Too Long

• Break into smaller pieces
• Check for blockers
• Review plan scope

Review Finding Many Issues

• Don't panic
• Prioritize by severity
• Fix incrementally
• Learn from feedback

Fix Introducing New Issues

• Roll back changes
• Fix one at a time
• Increase test coverage
• Get second review