vibeeval/vibecosystem/tdd

NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST

test('retries failed operations 3 times', async () => {
  let attempts = 0;
  const operation = () => {
    attempts++;
    if (attempts < 3) throw new Error('fail');
    return 'success';
  };
  const result = await retryOperation(operation);
  expect(result).toBe('success');
  expect(attempts).toBe(3);
});

test('retry works', async () => {
  const mock = jest.fn()
    .mockRejectedValueOnce(new Error())
    .mockResolvedValueOnce('success');
  await retryOperation(mock);
  expect(mock).toHaveBeenCalledTimes(3);
});

npm test path/to/test.test.ts
# or
pytest path/to/test_file.py

async function retryOperation<T>(fn: () => Promise<T>): Promise<T> {
  for (let i = 0; i < 3; i++) {
    try {
      return await fn();
    } catch (e) {
      if (i === 2) throw e;
    }
  }
  throw new Error('unreachable');
}

async function retryOperation<T>(
  fn: () => Promise<T>,
  options?: {
    maxRetries?: number;
    backoff?: 'linear' | 'exponential';
    onRetry?: (attempt: number) => void;
  }
): Promise<T> {
  // YAGNI - over-engineered
}

npm test path/to/test.test.ts

┌────────────┐    ┌──────────┐    ┌──────────┐    ┌───────────┐
│   plan-    │───▶│ arbiter  │───▶│  kraken  │───▶│ arbiter  │
│   agent    │    │          │    │          │    │           │
└────────────┘    └──────────┘    └──────────┘    └───────────┘
   Design          Write           Implement        Verify
   approach        failing         minimal          all tests
                   tests           code             pass

NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST

Task(
  subagent_type="plan-agent",
  prompt="""
  Design TDD approach for: [FEATURE_NAME]
 
  Define:
  1. What behaviors need to be tested
  2. Edge cases to cover
  3. Expected test structure
 
  DO NOT write any implementation code.
  Output: Test plan document
  """
)

Task(
  subagent_type="arbiter",
  prompt="""
  Write failing tests for: [FEATURE_NAME]
 
  Test plan: [from phase 1]
 
  Requirements:
  - Write tests FIRST
  - Run tests to confirm they FAIL
  - Tests must fail because feature is missing (not syntax errors)
  - Create clear test names describing expected behavior
 
  DO NOT write any implementation code.
  """
)

Task(
  subagent_type="kraken",
  prompt="""
  Implement MINIMAL code to pass tests: [FEATURE_NAME]
 
  Tests location: [test file path]
 
  Requirements:
  - Write ONLY enough code to make tests pass
  - No additional features beyond what tests require
  - No "improvements" or "enhancements"
  - Run tests after each change
 
  Follow Red-Green-Refactor strictly.
  """
)

Task(
  subagent_type="arbiter",
  prompt="""
  Validate TDD implementation: [FEATURE_NAME]
 
  - Run full test suite
  - Verify all new tests pass
  - Verify no existing tests broke
  - Check test coverage if available
  """
)

User: /tdd Add email validation to the signup form
 
Claude: Starting /tdd workflow for email validation...
 
Phase 1: Planning test cases...
[Spawns plan-agent]
Test plan:
- Valid email formats
- Invalid email formats
- Empty email rejection
- Edge cases (unicode, long emails)
 
Phase 2: Writing failing tests (RED)...
[Spawns arbiter]
✅ 8 tests written, all failing as expected
 
Phase 3: Implementing minimal code (GREEN)...
[Spawns kraken]
✅ All 8 tests now passing
 
Phase 4: Validating...
[Spawns arbiter]
✅ 247 tests passing (8 new), 0 failing
 
TDD workflow complete!

Task(
  subagent_type="kraken",
  prompt="""
  Refactor: [FEATURE_NAME]
 
  - Clean up code while keeping tests green
  - Remove duplication
  - Improve naming
  - Extract helpers if needed
 
  DO NOT add new behavior. Keep all tests passing.
  """
)